vclient: Add tests for C API thunks.

9 files changed, 45862 insertions, 0 deletions

diff --git a/build_proton.sh b/build_proton.sh
index e14fcbdd..5a7ea4ef 100755
--- a/build_proton.sh
+++ b/build_proton.sh
@@ -384,6 +384,23 @@ function build_vrclient64
     cp -a vrclient_x64.dll.fake "$DST_DIR"/lib64/wine/fakedlls/vrclient_x64.dll
 }
 
+function build_vrclient64_tests
+{
+    build_vrclient64
+
+    cp -a vrclient_x64/flatapi.c tests/
+    $AMD64_WRAPPER "$TOP"/wine/tools/winemaker/winemaker \
+        --nosource-fix --nolower-include --nodlls --nomsvcrt \
+        -I"$TOOLS_DIR64"/include/ \
+        -I"$TOOLS_DIR64"/include/wine/ \
+        -I"$TOOLS_DIR64"/include/wine/windows/ \
+        -I../vrclient_x64/ \
+        -L"$TOOLS_DIR64"/lib64/ \
+        -L"$TOOLS_DIR64"/lib64/wine/ \
+        tests
+    CXXFLAGS="-Wno-attributes -std=c++0x -O2 -g" CFLAGS="-O2 -g" PATH="$TOOLS_DIR64/bin:$PATH" $AMD64_WRAPPER make $JOBS -C tests
+}
+
 function build_vrclient32
 {
     cd "$TOP"
@@ -410,6 +427,23 @@ function build_vrclient32
     cp -a vrclient.dll.fake "$DST_DIR"/lib/wine/fakedlls/vrclient.dll
 }
 
+function build_vrclient32_tests
+{
+    build_vrclient32
+
+    cp -a vrclient/flatapi.c tests/
+    $I386_WRAPPER "$TOP"/wine/tools/winemaker/winemaker \
+        --nosource-fix --nolower-include --nodlls --nomsvcrt \
+        -I"$TOOLS_DIR32"/include/ \
+        -I"$TOOLS_DIR32"/include/wine/ \
+        -I"$TOOLS_DIR32"/include/wine/windows/ \
+        -I../vrclient/ \
+        -L"$TOOLS_DIR32"/lib/ \
+        -L"$TOOLS_DIR32"/lib/wine/ \
+        tests
+    CXXFLAGS="-Wno-attributes -std=c++0x -O2 -g" CFLAGS="-O2 -g" PATH="$TOOLS_DIR32/bin:$PATH" $I386_WRAPPER make $JOBS -C tests
+}
+
 function build_dxvk
 {
     #unfortunately the Steam chroots are too old to build DXVK, so we have to
@@ -596,6 +630,7 @@ case "$BUILD_COMPONENTS" in
     "lsteamclient") build_lsteamclient32; build_lsteamclient64 ;;
     "lsteamclient32") build_lsteamclient32 ;;
     "lsteamclient64") build_lsteamclient64 ;;
+    "vrclient_tests") build_vrclient32_tests; build_vrclient64_tests ;;
     *) echo "Invalid build components: $BUILD_COMPONENTS" ;;
 esac
 
diff --git a/vrclient_x64/gen.sh b/vrclient_x64/gen.sh
index 0d904858..847e104c 100755
--- a/vrclient_x64/gen.sh
+++ b/vrclient_x64/gen.sh
@@ -8,4 +8,7 @@ rm vrclient_x64/cpp*.h
 rm vrclient_x64/struct*.h
 rm vrclient_x64/struct*.cpp
 
+rm tests/*_autogen.c
+rm tests/*_autogen.h
+
 ./gen_wrapper.py
diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py
index c89f1def..83f88d3a 100755
--- a/vrclient_x64/gen_wrapper.py
+++ b/vrclient_x64/gen_wrapper.py
@@ -553,6 +553,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
         for alias in aliases[iface_version]:
             constructors.write("    {\"%s\", &create_%s}, /* alias */\n" % (alias, winclassname))
 
+    generate_c_api_thunk_tests(winclassname, methods, method_names)
+
 
 generated_struct_handlers = []
 cpp_files_need_close_brace = []
@@ -757,6 +759,190 @@ extern void call_flat_method_f(void);
 
         f.write("#endif\n")
 
+def generate_c_api_method_test(f, header, thunks_c, class_name, method_name, method):
+    thunk_params = get_capi_thunk_params(method)
+    f.write("\n    init_thunk(t, this_ptr_value, %s_%s, %s);\n" % (class_name, method_name, thunk_params))
+    f.write("    ")
+    header.write("\n")
+    thunks_c.write("\n")
+
+    returns_record = method.result_type.get_canonical().kind == clang.cindex.TypeKind.RECORD
+    if returns_record:
+        f.write("%s *" % strip_ns(method.result_type.spelling))
+        header.write("%s *" % strip_ns(method.result_type.spelling))
+        thunks_c.write("%s *" % strip_ns(method.result_type.spelling))
+    else:
+        f.write("%s " % strip_ns(method.result_type.spelling))
+        header.write("%s " % strip_ns(method.result_type.spelling))
+        thunks_c.write("%s " % strip_ns(method.result_type.spelling))
+    first_param = True
+    f.write('(__stdcall *capi_%s_%s)(' % (class_name, method_name))
+    header.write('__thiscall %s_%s(void *_this' % (class_name, method_name))
+    thunks_c.write('__thiscall %s_%s(void *_this' % (class_name, method_name))
+    if returns_record:
+        f.write("%s *_r" % strip_ns(method.result_type.spelling))
+        first_param = False
+        header.write(", %s *_r" % strip_ns(method.result_type.spelling))
+        thunks_c.write(", %s *_r" % strip_ns(method.result_type.spelling))
+
+    for param in get_params(method):
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                and param.type.get_pointee().kind == clang.cindex.TypeKind.UNEXPOSED:
+            typename = "void *"
+        else:
+            typename = param.type.spelling.split("::")[-1].replace("&", "*");
+        if not first_param:
+            f.write(", ")
+        first_param = False
+        f.write("%s %s" % (typename, param.spelling))
+        header.write(", %s %s" % (typename, param.spelling))
+        thunks_c.write(", %s %s" % (typename, param.spelling))
+    f.write(") = (void *)t;\n")
+    header.write(");\n")
+    thunks_c.write(")\n{\n")
+
+    thunks_c.write("    push_ptr_parameter(_this);\n")
+    if returns_record:
+        thunks_c.write("    push_ptr_parameter(_r);\n")
+    for param in get_params(method):
+        param_size = param.type.get_size()
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                or param.type.spelling.endswith("&") \
+                or param.type.spelling == "vr::glSharedTextureHandle_t":
+            typename = "ptr"
+        elif param.type.spelling == "bool":
+            typename = "bool"
+        elif param.type.spelling == "float":
+            typename = "float"
+        elif param.type.spelling == "vr::HmdRect2_t":
+            typename = "HmdRect2"
+        elif param.type.spelling == "vr::HmdVector2_t":
+            typename = "HmdVector2"
+        elif param.type.spelling == "vr::HmdVector3_t":
+            typename = "HmdVector3"
+        elif param.type.spelling == "vr::HmdColor_t":
+            typename = "HmdColor"
+        elif param_size == 8:
+            typename = "uint64"
+        elif param_size == 4 or param_size == 2:
+            typename = "uint32"
+        else:
+            typename = "unknown"
+        thunks_c.write("    push_%s_parameter(%s);\n" % (typename, param.spelling))
+    if method.result_type.kind != clang.cindex.TypeKind.VOID:
+        thunks_c.write("    return 0;\n")
+    thunks_c.write("}\n")
+
+    parameter_checks = []
+    def add_parameter_check(typename, value):
+        parameter_checks.append("check_%s_parameter(\"%s_%s\", %s)" % (typename, class_name, method_name, value))
+    add_parameter_check("ptr", "this_ptr_value")
+    f.write("\n")
+    f.write("    clear_parameters();\n")
+    f.write("    capi_%s_%s(" % (class_name, method_name))
+    first_param = True
+    if returns_record:
+        f.write("data_ptr_value")
+        first_param = False
+        add_parameter_check("ptr", "data_ptr_value")
+    for i, param in enumerate(get_params(method)):
+        i += 1
+        param_size = param.type.get_size()
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                or param.type.spelling.endswith("&") \
+                or param.type.spelling == "vr::glSharedTextureHandle_t":
+            v = "(void *)%s" % i
+            add_parameter_check("ptr", v)
+        elif param.type.spelling == "bool":
+            v = "1"
+            add_parameter_check("bool", v)
+        elif param.type.spelling == "float":
+            v = "%s.0f" % i
+            add_parameter_check("float", v)
+        elif param.type.spelling == "vr::HmdRect2_t":
+            v = "DEFAULT_RECT";
+            add_parameter_check("HmdRect2", v)
+        elif param.type.spelling == "vr::HmdVector2_t":
+            v = "DEFAULT_VECTOR2";
+            add_parameter_check("HmdVector2", v)
+        elif param.type.spelling == "vr::HmdVector3_t":
+            v = "DEFAULT_VECTOR3";
+            add_parameter_check("HmdVector3", v)
+        elif param.type.spelling == "vr::HmdColor_t":
+            v = "DEFAULT_COLOR";
+            add_parameter_check("HmdColor", v)
+        elif param_size == 8:
+            v = str(i)
+            add_parameter_check("uint64", v)
+        elif param_size == 4 or param_size == 2:
+            v = str(i)
+            add_parameter_check("uint32", v)
+        if not first_param:
+            f.write(", ")
+        first_param = False
+        f.write(v)
+    f.write(");\n")
+    for c in parameter_checks:
+        f.write("    %s;\n" % c)
+
+def generate_c_api_thunk_tests(winclassname, methods, method_names):
+    class_name = re.sub(r'^win[A-Za-z]+_', '', winclassname)
+
+    filename = "tests/capi_thunks_autogen.h"
+    file_exists = os.path.isfile(filename)
+    header = open(filename, "a")
+    if not file_exists:
+        header.write("""/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+
+#include "cxx.h"
+#include "flatapi.h"
+#include "vrclient_defs.h"
+
+#include "capi_thunks.h"
+""")
+    header.write("\nvoid test_capi_thunks_%s(void);\n" % class_name)
+
+    filename = "tests/capi_thunks_autogen.c"
+    file_exists = os.path.isfile(filename)
+    thunks_c = open(filename, "a")
+    if not file_exists:
+        thunks_c.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+""")
+
+    filename = "tests/capi_thunks_tests_autogen.c"
+    file_exists = os.path.isfile(filename)
+    with open(filename, "a") as f:
+        if not file_exists:
+            f.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+""")
+        f.write("\nvoid test_capi_thunks_%s(void)\n{\n" % class_name)
+        f.write("    struct thunk *t = alloc_thunks(1);\n");
+        for i in range(len(methods)):
+            generate_c_api_method_test(f, header, thunks_c, class_name, method_names[i], methods[i])
+        f.write("    VirtualFree(t, 0, MEM_RELEASE);\n")
+        f.write("}\n")
+
+    filename = "tests/main_autogen.c"
+    file_exists = os.path.isfile(filename)
+    with open(filename, "a") as f:
+        if not file_exists:
+            f.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+#include <stdio.h>
+
+int main(void)
+{
+""")
+        f.write("    test_capi_thunks_%s();\n" % class_name)
+
 
 #clang.cindex.Config.set_library_file("/usr/lib/llvm-3.8/lib/libclang-3.8.so.1");
 
@@ -806,4 +992,8 @@ for f in cpp_files_need_close_brace:
     m = open(f, "a")
     m.write("\n}\n")
 
+with open("tests/main_autogen.c", "a") as f:
+    f.write("    printf(\"All tests executed.\\n\");\n")
+    f.write("}\n")
+
 generate_flatapi_c()
diff --git a/vrclient_x64/tests/capi_thunks.c b/vrclient_x64/tests/capi_thunks.c
new file mode 100644
index 00000000..46d2a257
--- /dev/null
+++ b/vrclient_x64/tests/capi_thunks.c
@@ -0,0 +1,289 @@
+#include "capi_thunks_autogen.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX_PARAMETERS 20
+
+HmdRect2_t DEFAULT_RECT;
+HmdVector2_t DEFAULT_VECTOR2;
+HmdVector3_t DEFAULT_VECTOR3;
+HmdColor_t DEFAULT_COLOR;
+
+enum parameter_type
+{
+    PT_PTR,
+    PT_BOOL,
+    PT_FLOAT,
+    PT_UINT32,
+    PT_UINT64,
+    PT_HMDRECT2,
+    PT_HMDVECTOR2,
+    PT_HMDVECTOR3,
+    PT_HMDCOLOR,
+};
+
+struct parameter
+{
+    enum parameter_type pt;
+    union
+    {
+        const void *ptr;
+        bool b;
+        float f;
+        uint32_t u32;
+        uint64_t u64;
+        HmdRect2_t hmd_rect2;
+        HmdVector2_t hmd_vector2;
+        HmdVector3_t hmd_vector3;
+        HmdColor_t hmd_color;
+    } value;
+};
+
+static struct
+{
+    unsigned int parameter_index;
+    unsigned int parameter_count;
+    struct parameter parameters[MAX_PARAMETERS];
+}
+params;
+
+void clear_parameters(void)
+{
+    memset(&params, 0, sizeof(params));
+}
+
+struct parameter *get_next_parameter(void)
+{
+    assert(params.parameter_count < MAX_PARAMETERS);
+    return &params.parameters[params.parameter_count++];
+}
+
+struct parameter *get_pushed_parameter(void)
+{
+    assert(params.parameter_index < params.parameter_count);
+    return &params.parameters[params.parameter_index++];
+}
+
+void push_ptr_parameter(const void *v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_PTR;
+    param->value.ptr = v;
+}
+
+void push_bool_parameter(bool b)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_BOOL;
+    param->value.b = b;
+}
+
+void push_float_parameter(float f)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_FLOAT;
+    param->value.f = f;
+}
+
+void push_uint32_parameter(uint32_t u)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_UINT32;
+    param->value.u32 = u;
+}
+
+void push_uint64_parameter(uint64_t u)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_UINT64;
+    param->value.u64 = u;
+}
+
+void push_HmdRect2_parameter(HmdRect2_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDRECT2;
+    param->value.hmd_rect2 = v;
+}
+
+void push_HmdVector2_parameter(HmdVector2_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDVECTOR2;
+    param->value.hmd_vector2 = v;
+}
+
+void push_HmdVector3_parameter(HmdVector3_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDVECTOR3;
+    param->value.hmd_vector3 = v;
+
+}
+
+void push_HmdColor_parameter(HmdColor_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDCOLOR;
+    param->value.hmd_color = v;
+}
+
+void check_ptr_parameter_(const char *file, unsigned int line, const char *name, const void *v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_PTR)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.ptr != v)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %p, expected %p.\n", file, line, name, i, param->value.ptr, v);
+        exit(-1);
+    }
+}
+
+void check_bool_parameter_(const char *file, unsigned int line, const char *name, bool b)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_BOOL)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.b != b)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %#x, expected %#x.\n", file, line, name, i, param->value.b, b);
+        exit(-1);
+    }
+}
+
+void check_float_parameter_(const char *file, unsigned int line, const char *name, float f)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_FLOAT)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.f != f)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %.8ex, expected %.8ex.\n", file, line, name, i, param->value.f, f);
+        exit(-1);
+    }
+}
+
+void check_uint32_parameter_(const char *file, unsigned int line, const char *name, uint32_t u)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_UINT32)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.u32 != u)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %"PRIu32", expected %"PRIu32".\n",
+                file, line, name, i, param->value.u32, u);
+        exit(-1);
+    }
+}
+
+void check_uint64_parameter_(const char *file, unsigned int line, const char *name, uint64_t u)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_UINT64)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.u64 != u)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %"PRIu64", expected %"PRIu64".\n",
+                file, line, name, i, param->value.u64, u);
+        exit(-1);
+    }
+}
+
+void check_HmdRect2_parameter_(const char *file, unsigned int line, const char *name, HmdRect2_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDRECT2)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdRect2\n");
+}
+
+void check_HmdVector2_parameter_(const char *file, unsigned int line, const char *name, HmdVector2_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDVECTOR2)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdVector2\n");
+}
+
+void check_HmdVector3_parameter_(const char *file, unsigned int line, const char *name, HmdVector3_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDVECTOR3)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdVector3\n");
+}
+
+void check_HmdColor_parameter_(const char *file, unsigned int line, const char *name, HmdColor_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDCOLOR)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdColor\n");
+}
diff --git a/vrclient_x64/tests/capi_thunks.h b/vrclient_x64/tests/capi_thunks.h
new file mode 100644
index 00000000..08b450fa
--- /dev/null
+++ b/vrclient_x64/tests/capi_thunks.h
@@ -0,0 +1,43 @@
+#ifdef __i386__
+# define this_ptr_value ((void *)0xdeadbeef)
+#else
+# define this_ptr_value ((void *)0xdeadbeefdeadc0de)
+#endif
+
+#define data_ptr_value ((void *)0xd474)
+
+extern void clear_parameters(void);
+
+extern HmdRect2_t DEFAULT_RECT;
+extern HmdVector2_t DEFAULT_VECTOR2;
+extern HmdVector3_t DEFAULT_VECTOR3;
+extern HmdColor_t DEFAULT_COLOR;
+
+extern void push_ptr_parameter(const void *v);
+extern void push_bool_parameter(bool b);
+extern void push_float_parameter(float f);
+extern void push_uint32_parameter(uint32_t u);
+extern void push_uint64_parameter(uint64_t u);
+extern void push_HmdRect2_parameter(HmdRect2_t v);
+extern void push_HmdVector2_parameter(HmdVector2_t v);
+extern void push_HmdVector3_parameter(HmdVector3_t v);
+extern void push_HmdColor_parameter(HmdColor_t v);
+
+#define check_ptr_parameter(a, b) check_ptr_parameter_(__FILE__, __LINE__, a, b)
+extern void check_ptr_parameter_(const char *file, unsigned int line, const char *name, const void *v);
+#define check_bool_parameter(a, b) check_bool_parameter_(__FILE__, __LINE__, a, b)
+extern void check_bool_parameter_(const char *file, unsigned int line, const char *name, bool b);
+#define check_float_parameter(a, b) check_float_parameter_(__FILE__, __LINE__, a, b)
+extern void check_float_parameter_(const char *file, unsigned int line, const char *name, float f);
+#define check_uint32_parameter(a, b) check_uint32_parameter_(__FILE__, __LINE__, a, b)
+extern void check_uint32_parameter_(const char *file, unsigned int line, const char *name, uint32_t u);
+#define check_uint64_parameter(a, b) check_uint64_parameter_(__FILE__, __LINE__, a, b)
+extern void check_uint64_parameter_(const char *file, unsigned int line, const char *name, uint64_t u);
+#define check_HmdRect2_parameter(a, b) check_HmdRect2_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdRect2_parameter_(const char *file, unsigned int line, const char *name, HmdRect2_t v);
+#define check_HmdVector2_parameter(a, b) check_HmdVector2_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdVector2_parameter_(const char *file, unsigned int line, const char *name, HmdVector2_t v);
+#define check_HmdVector3_parameter(a, b) check_HmdVector3_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdVector3_parameter_(const char *file, unsigned int line, const char *name, HmdVector3_t v);
+#define check_HmdColor_parameter(a, b) check_HmdColor_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdColor_parameter_(const char *file, unsigned int line, const char *name, HmdColor_t v);
diff --git a/vrclient_x64/tests/capi_thunks_autogen.c b/vrclient_x64/tests/capi_thunks_autogen.c
new file mode 100644
index 00000000..279e2191
--- /dev/null
+++ b/vrclient_x64/tests/capi_thunks_autogen.c
@@ -0,0 +1,18507 @@
+/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+void __thiscall IVRSystem_019_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_019_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_019_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_019_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+void __thiscall IVRSystem_019_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnDevice);
+    push_uint32_parameter(textureType);
+    push_ptr_parameter(pInstance);
+}
+
+bool __thiscall IVRSystem_019_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_019_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_019_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_019_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_019_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_019_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_019_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_019_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_uint32_parameter(propType);
+    push_ptr_parameter(pBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_019_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_019_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_019_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_019_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_019_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_IsInputAvailable(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_IsSteamVRDrawingControllers(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_ShouldApplicationPause(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_019_ShouldApplicationReduceRenderingWork(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_019_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_019_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_019_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_019_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchTemplateAppKey);
+    push_ptr_parameter(pchNewAppKey);
+    push_ptr_parameter(pKeys);
+    push_uint32_parameter(unKeys);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchArgs);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_ptr_parameter(pchMimeType);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_ptr_parameter(pchMimeTypesBuffer);
+    push_uint32_parameter(unMimeTypesBuffer);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchAppKeysThatSupportBuffer);
+    push_uint32_parameter(unAppKeysThatSupportBuffer);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unHandle);
+    push_ptr_parameter(pchArgs);
+    push_uint32_parameter(unArgs);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBinaryPath);
+    push_ptr_parameter(pchArguments);
+    push_ptr_parameter(pchWorkingDirectory);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+const char * __thiscall IVRSettings_002_GetSettingsErrorNameFromEnum(void *_this, EVRSettingsError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+bool __thiscall IVRSettings_002_Sync(void *_this, bool bForce, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bForce);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+void __thiscall IVRSettings_002_SetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_bool_parameter(bValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_002_SetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_uint32_parameter(nValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_002_SetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_float_parameter(flValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_002_SetString(void *_this, const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(pchValue);
+    push_ptr_parameter(peError);
+}
+
+bool __thiscall IVRSettings_002_GetBool(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+int32_t __thiscall IVRSettings_002_GetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+float __thiscall IVRSettings_002_GetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+void __thiscall IVRSettings_002_GetString(void *_this, const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unValueLen);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_002_RemoveSection(void *_this, const char * pchSection, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_002_RemoveKeyInSection(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(peError);
+}
+
+ChaperoneCalibrationState __thiscall IVRChaperone_003_GetCalibrationState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRChaperone_003_GetPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSizeX);
+    push_ptr_parameter(pSizeZ);
+    return 0;
+}
+
+bool __thiscall IVRChaperone_003_GetPlayAreaRect(void *_this, HmdQuad_t * rect)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(rect);
+    return 0;
+}
+
+void __thiscall IVRChaperone_003_ReloadInfo(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRChaperone_003_SetSceneColor(void *_this, HmdColor_t color)
+{
+    push_ptr_parameter(_this);
+    push_HmdColor_parameter(color);
+}
+
+void __thiscall IVRChaperone_003_GetBoundsColor(void *_this, HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t * pOutputCameraColor)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputColorArray);
+    push_uint32_parameter(nNumOutputColors);
+    push_float_parameter(flCollisionBoundsFadeDistance);
+    push_ptr_parameter(pOutputCameraColor);
+}
+
+bool __thiscall IVRChaperone_003_AreBoundsVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRChaperone_003_ForceBoundsVisible(void *_this, bool bForce)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bForce);
+}
+
+bool __thiscall IVRChaperoneSetup_005_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(configFile);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_005_RevertWorkingCopy(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSizeX);
+    push_ptr_parameter(pSizeZ);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingPlayAreaRect(void *_this, HmdQuad_t * rect)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(rect);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatSeatedZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatStandingZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingPlayAreaSize(void *_this, float sizeX, float sizeZ)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(sizeX);
+    push_float_parameter(sizeZ);
+}
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_uint32_parameter(unQuadsCount);
+}
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pMatSeatedZeroPoseToRawTrackingPose);
+}
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pMatStandingZeroPoseToRawTrackingPose);
+}
+
+void __thiscall IVRChaperoneSetup_005_ReloadFromDisk(void *_this, EChaperoneConfigFile configFile)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(configFile);
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatSeatedZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo(void *_this, uint8_t * pTagsBuffer, uint32_t unTagCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTagsBuffer);
+    push_uint32_parameter(unTagCount);
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo(void *_this, uint8_t * pTagsBuffer, uint32_t * punTagCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTagsBuffer);
+    push_ptr_parameter(punTagCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_uint32_parameter(unQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_ExportLiveToBuffer(void *_this, char * pBuffer, uint32_t * pnBufferLength)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pBuffer);
+    push_ptr_parameter(pnBufferLength);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_005_ImportFromBufferToWorking(void *_this, const char * pBuffer, uint32_t nImportFlags)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pBuffer);
+    push_uint32_parameter(nImportFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_022_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_022_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_022_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_022_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_022_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_022_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_022_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_022_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_022_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_022_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_022_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_022_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_022_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_022_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_022_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11ShaderResourceView);
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_022_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_022_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+uint32_t __thiscall IVRCompositor_022_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_022_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPhysicalDevice);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_022_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTimingMode);
+}
+
+EVRCompositorError __thiscall IVRCompositor_022_SubmitExplicitTimingData(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulUserValue);
+    push_uint32_parameter(type);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(style);
+    push_ptr_parameter(pImage);
+    push_ptr_parameter(pNotificationId);
+    return 0;
+}
+
+EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(notificationId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_018_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_018_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_018_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_018_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_018_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_018_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pColor);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchRenderModel);
+    push_ptr_parameter(pColor);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_018_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(vCenter);
+    push_float_parameter(fRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(pvCenter);
+    push_ptr_parameter(pfRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPIType);
+    push_ptr_parameter(pColorSpace);
+    push_ptr_parameter(pTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_018_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_018_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_018_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_018_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_018_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_018_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_018_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_018_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_ptr_parameter(pchCaption);
+    push_ptr_parameter(pchButton0Text);
+    push_ptr_parameter(pchButton1Text);
+    push_ptr_parameter(pchButton2Text);
+    push_ptr_parameter(pchButton3Text);
+    return 0;
+}
+
+void __thiscall IVROverlay_018_CloseMessageOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(ppRenderModel);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_005_FreeRenderModel(void *_this, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderModel);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(ppTexture);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_005_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTexture);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(pD3D11Device);
+    push_ptr_parameter(ppD3D11Texture2D);
+    return 0;
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadIntoTextureD3D11_Async(void *_this, TextureID_t textureId, void * pDstTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(pDstTexture);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_005_FreeTextureD3D11(void *_this, void * pD3D11Texture2D)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11Texture2D);
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unRenderModelIndex);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unRenderModelNameLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentCount(void *_this, const char * pchRenderModelName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unComponentIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameLen);
+    return 0;
+}
+
+uint64_t __thiscall IVRRenderModels_005_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pchComponentRenderModelName);
+    push_uint32_parameter(unComponentRenderModelNameLen);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_005_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pState);
+    push_ptr_parameter(pComponentState);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_005_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelThumbnailURL(void *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchThumbnailURL);
+    push_uint32_parameter(unThumbnailURLLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelOriginalPath(void *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchOriginalPath);
+    push_uint32_parameter(unOriginalPathLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+const char * __thiscall IVRRenderModels_005_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+    push_ptr_parameter(pnAdapterOutputIndex);
+}
+
+const char * __thiscall IVRTrackedCamera_003_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eCameraError);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pHasCamera);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+    push_ptr_parameter(pnFrameBufferSize);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pFocalLength);
+    push_ptr_parameter(pCenter);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_float_parameter(flZNear);
+    push_float_parameter(flZFar);
+    push_ptr_parameter(pProjection);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pHandle);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pFrameBuffer);
+    push_uint32_parameter(nFrameBufferSize);
+    push_ptr_parameter(pFrameHeader);
+    push_uint32_parameter(nFrameHeaderSize);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pTextureBounds);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    push_ptr_parameter(pFrameHeader);
+    push_uint32_parameter(nFrameHeaderSize);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pFrameHeader);
+    push_uint32_parameter(nFrameHeaderSize);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    push_uint32_parameter(glTextureId);
+    return 0;
+}
+
+EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutScreenshotHandle);
+    push_uint32_parameter(type);
+    push_ptr_parameter(pchPreviewFilename);
+    push_ptr_parameter(pchVRFilename);
+    return 0;
+}
+
+EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSupportedTypes);
+    push_uint32_parameter(numTypes);
+    return 0;
+}
+
+EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(screenshotHandle);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(screenshotHandle);
+    push_uint32_parameter(filenameType);
+    push_ptr_parameter(pchFilename);
+    push_uint32_parameter(cchFilename);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(screenshotHandle);
+    push_float_parameter(flProgress);
+    return 0;
+}
+
+EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutScreenshotHandle);
+    push_ptr_parameter(pchPreviewFilename);
+    push_ptr_parameter(pchVRFilename);
+    return 0;
+}
+
+EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(screenshotHandle);
+    push_uint32_parameter(type);
+    push_ptr_parameter(pchSourcePreviewFilename);
+    push_ptr_parameter(pchSourceVRFilename);
+    return 0;
+}
+
+uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchResourceName);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchResourceName);
+    push_ptr_parameter(pchResourceTypeDirectory);
+    push_ptr_parameter(pchPathBuffer);
+    push_uint32_parameter(unBufferLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDriver);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchDriverName);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_SetActionManifestPath(void *_this, const char * pchActionManifestPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchActionManifestPath);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchActionSetName);
+    push_ptr_parameter(pHandle);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchActionName);
+    push_ptr_parameter(pHandle);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchInputSourcePath);
+    push_ptr_parameter(pHandle);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSets);
+    push_uint32_parameter(unSizeOfVRSelectedActionSet_t);
+    push_uint32_parameter(unSetCount);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_ptr_parameter(pActionData);
+    push_uint32_parameter(unActionDataSize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_ptr_parameter(pActionData);
+    push_uint32_parameter(unActionDataSize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetPoseActionData(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsFromNow);
+    push_ptr_parameter(pActionData);
+    push_uint32_parameter(unActionDataSize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetSkeletalActionData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_uint32_parameter(eBoneParent);
+    push_float_parameter(fPredictedSecondsFromNow);
+    push_ptr_parameter(pActionData);
+    push_uint32_parameter(unActionDataSize);
+    push_ptr_parameter(pTransformArray);
+    push_uint32_parameter(unTransformArrayCount);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetSkeletalActionDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_uint32_parameter(eBoneParent);
+    push_float_parameter(fPredictedSecondsFromNow);
+    push_ptr_parameter(pvCompressedData);
+    push_uint32_parameter(unCompressedSize);
+    push_ptr_parameter(punRequiredCompressedSize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_UncompressSkeletalActionData(void *_this, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pvCompressedBuffer);
+    push_uint32_parameter(unCompressedBufferSize);
+    push_ptr_parameter(peBoneParent);
+    push_ptr_parameter(pTransformArray);
+    push_uint32_parameter(unTransformArrayCount);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(action);
+    push_float_parameter(fStartSecondsFromNow);
+    push_float_parameter(fDurationSeconds);
+    push_float_parameter(fFrequency);
+    push_float_parameter(fAmplitude);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(actionSetHandle);
+    push_uint64_parameter(digitalActionHandle);
+    push_ptr_parameter(originsOut);
+    push_uint32_parameter(originOutCount);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(origin);
+    push_ptr_parameter(pchNameArray);
+    push_uint32_parameter(unNameArraySize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(origin);
+    push_ptr_parameter(pOriginInfo);
+    push_uint32_parameter(unOriginInfoSize);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(actionSetHandle);
+    push_uint64_parameter(ulActionHandle);
+    return 0;
+}
+
+EVRInputError __thiscall IVRInput_003_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSets);
+    push_uint32_parameter(unSizeOfVRSelectedActionSet_t);
+    push_uint32_parameter(unSetCount);
+    push_uint64_parameter(originToHighlight);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchPath);
+    push_uint32_parameter(mode);
+    push_uint32_parameter(unElementSize);
+    push_uint32_parameter(unElements);
+    push_ptr_parameter(pulBuffer);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    push_ptr_parameter(pDst);
+    push_uint32_parameter(unBytes);
+    push_ptr_parameter(punRead);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    push_ptr_parameter(pSrc);
+    push_uint32_parameter(unBytes);
+    return 0;
+}
+
+PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    return 0;
+}
+
+EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eApplicationType);
+    push_ptr_parameter(pStartupInfo);
+    return 0;
+}
+
+void __thiscall IVRClientCore_003_Cleanup(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchInterfaceVersion);
+    return 0;
+}
+
+void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchNameAndVersion);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_017_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_017_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_017_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+void __thiscall IVRSystem_017_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnDevice);
+    push_uint32_parameter(textureType);
+    push_ptr_parameter(pInstance);
+}
+
+bool __thiscall IVRSystem_017_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_017_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_017_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_017_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_017_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_017_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_017_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_017_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_017_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_017_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_017_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_017_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_017_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_017_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_017_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_017_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_017_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_017_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_017_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_017_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_017_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVROverlayError __thiscall IVROverlay_017_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_017_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_017_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_017_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_017_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_017_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_017_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pColor);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchRenderModel);
+    push_ptr_parameter(pColor);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_017_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(vCenter);
+    push_float_parameter(fRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(pvCenter);
+    push_ptr_parameter(pfRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPIType);
+    push_ptr_parameter(pColorSpace);
+    push_ptr_parameter(pTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_017_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_017_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_017_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_017_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_017_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_017_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_017_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_017_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_ptr_parameter(pchCaption);
+    push_ptr_parameter(pchButton0Text);
+    push_ptr_parameter(pchButton1Text);
+    push_ptr_parameter(pchButton2Text);
+    push_ptr_parameter(pchButton3Text);
+    return 0;
+}
+
+void __thiscall IVROverlay_017_CloseMessageOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_021_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_021_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_021_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_021_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_021_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_021_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_021_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_021_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_021_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_021_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_021_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_021_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_021_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_021_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_021_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11ShaderResourceView);
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_021_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_021_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+uint32_t __thiscall IVRCompositor_021_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_021_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPhysicalDevice);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_021_SetExplicitTimingMode(void *_this, bool bExplicitTimingMode)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bExplicitTimingMode);
+}
+
+EVRCompositorError __thiscall IVRCompositor_021_SubmitExplicitTimingData(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_016_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_016_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_016_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_016_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_016_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_016_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pColor);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchRenderModel);
+    push_ptr_parameter(pColor);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_016_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPIType);
+    push_ptr_parameter(pColorSpace);
+    push_ptr_parameter(pTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_016_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_016_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_016_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_016_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_016_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_016_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_016_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_016_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_ptr_parameter(pchCaption);
+    push_ptr_parameter(pchButton0Text);
+    push_ptr_parameter(pchButton1Text);
+    push_ptr_parameter(pchButton2Text);
+    push_ptr_parameter(pchButton3Text);
+    return 0;
+}
+
+void __thiscall IVROverlay_016_CloseMessageOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_016_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_016_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_016_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_016_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+void __thiscall IVRSystem_016_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnDevice);
+    push_uint32_parameter(textureType);
+}
+
+bool __thiscall IVRSystem_016_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_016_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_016_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_016_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_016_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_016_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_016_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_016_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_016_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_016_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_016_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_016_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_016_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_016_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_016_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_016_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_016_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_016_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_016_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_016_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_016_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_020_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_020_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_020_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_020_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_020_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_020_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_020_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_020_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_020_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_020_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_020_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_020_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_020_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_020_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_020_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11ShaderResourceView);
+}
+
+EVRCompositorError __thiscall IVRCompositor_020_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_020_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_020_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_020_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+uint32_t __thiscall IVRCompositor_020_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_020_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPhysicalDevice);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+EVRInitError __thiscall IVRClientCore_002_Init(void *_this, EVRApplicationType eApplicationType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eApplicationType);
+    return 0;
+}
+
+void __thiscall IVRClientCore_002_Cleanup(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVRInitError __thiscall IVRClientCore_002_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchInterfaceVersion);
+    return 0;
+}
+
+void * __thiscall IVRClientCore_002_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchNameAndVersion);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRClientCore_002_BIsHmdPresent(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+const char * __thiscall IVRClientCore_002_GetEnglishStringForHmdError(void *_this, EVRInitError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+const char * __thiscall IVRClientCore_002_GetIDForVRInitError(void *_this, EVRInitError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_015_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_015_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_015_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_015_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_015_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_015_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_015_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_015_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_015_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_015_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_015_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_015_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_015_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_015_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_015_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_015_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_015_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_015_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_015_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_015_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_015_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_015_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_015_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_015_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVROverlayError __thiscall IVROverlay_014_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_014_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_014_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_014_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_014_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_014_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_014_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPIType);
+    push_ptr_parameter(pColorSpace);
+    push_ptr_parameter(pTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_014_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_014_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_014_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_014_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_014_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_014_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_014_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_014_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_ptr_parameter(pchCaption);
+    push_ptr_parameter(pchButton0Text);
+    push_ptr_parameter(pchButton1Text);
+    push_ptr_parameter(pchButton2Text);
+    push_ptr_parameter(pchButton3Text);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_019_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_019_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_019_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_019_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_019_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_019_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_019_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_019_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_019_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_019_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_019_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_019_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_019_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_019_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_019_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_019_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_019_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_019_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_019_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+uint32_t __thiscall IVRCompositor_019_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_019_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPhysicalDevice);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_014_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_014_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_014_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_014_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_014_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_014_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_014_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_014_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_014_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_014_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_014_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_014_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_014_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_014_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_014_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_014_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_014_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_014_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_014_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_014_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_014_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_014_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_014_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_014_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_018_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_018_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_018_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_018_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_018_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_018_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_018_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_018_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_018_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_018_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_018_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_018_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_018_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_018_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_018_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_018_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_018_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_018_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_018_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+EVROverlayError __thiscall IVROverlay_013_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_013_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_013_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_013_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_013_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_013_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_013_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPI);
+    push_ptr_parameter(pColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_013_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_013_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_013_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_013_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_013_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_013_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_013_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_013_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_012_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_012_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_012_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_012_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_012_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_012_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_012_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_012_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_012_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_012_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_012_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_012_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_012_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_012_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_012_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_012_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_012_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_012_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_012_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_012_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_012_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_012_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_012_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_012_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_016_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_016_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_016_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_016_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_016_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_016_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_016_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_016_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_016_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_016_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_016_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_016_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_016_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_016_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_016_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_016_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_016_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+const char * __thiscall IVRSettings_001_GetSettingsErrorNameFromEnum(void *_this, EVRSettingsError eError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eError);
+    return 0;
+}
+
+bool __thiscall IVRSettings_001_Sync(void *_this, bool bForce, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bForce);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRSettings_001_GetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bDefaultValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_bool_parameter(bDefaultValue);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+void __thiscall IVRSettings_001_SetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_bool_parameter(bValue);
+    push_ptr_parameter(peError);
+}
+
+int32_t __thiscall IVRSettings_001_GetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nDefaultValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_uint32_parameter(nDefaultValue);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+void __thiscall IVRSettings_001_SetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_uint32_parameter(nValue);
+    push_ptr_parameter(peError);
+}
+
+float __thiscall IVRSettings_001_GetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flDefaultValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_float_parameter(flDefaultValue);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+void __thiscall IVRSettings_001_SetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_float_parameter(flValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_001_GetString(void *_this, const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, const char * pchDefaultValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unValueLen);
+    push_ptr_parameter(pchDefaultValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_001_SetString(void *_this, const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(pchValue);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_001_RemoveSection(void *_this, const char * pchSection, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(peError);
+}
+
+void __thiscall IVRSettings_001_RemoveKeyInSection(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchSection);
+    push_ptr_parameter(pchSettingsKey);
+    push_ptr_parameter(peError);
+}
+
+EVRApplicationError __thiscall IVRApplications_005_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_005_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_005_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchTemplateAppKey);
+    push_ptr_parameter(pchNewAppKey);
+    push_ptr_parameter(pKeys);
+    push_uint32_parameter(unKeys);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+bool __thiscall IVRApplications_005_CancelApplicationLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_005_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_005_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_005_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_005_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint64_t __thiscall IVRApplications_005_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_005_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_005_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_005_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_005_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBinaryPath);
+    push_ptr_parameter(pchArguments);
+    push_ptr_parameter(pchWorkingDirectory);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_015_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_015_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_015_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_015_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_015_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_015_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_015_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_015_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_015_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_015_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_015_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_015_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_015_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_RequestScreenshot(void *_this, EVRScreenshotType type, const char * pchDestinationFileName, const char * pchVRDestinationFileName)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(type);
+    push_ptr_parameter(pchDestinationFileName);
+    push_ptr_parameter(pchVRDestinationFileName);
+    return 0;
+}
+
+EVRScreenshotType __thiscall IVRCompositor_015_GetCurrentScreenshotType(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_015_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_015_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_015_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_015_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+EVROverlayError __thiscall IVROverlay_012_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_012_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_012_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_012_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_012_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_012_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_012_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPI);
+    push_ptr_parameter(pColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_012_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_012_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_012_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_012_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_012_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_012_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_012_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_012_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+const char * __thiscall IVRTrackedCamera_002_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eCameraError);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pHasCamera);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+    push_ptr_parameter(pnFrameBufferSize);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraIntrinisics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pFocalLength);
+    push_ptr_parameter(pCenter);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(eFrameType);
+    push_float_parameter(flZNear);
+    push_float_parameter(flZFar);
+    push_ptr_parameter(pProjection);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pHandle);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    return 0;
+}
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(hTrackedCamera);
+    push_uint32_parameter(eFrameType);
+    push_ptr_parameter(pFrameBuffer);
+    push_uint32_parameter(nFrameBufferSize);
+    push_ptr_parameter(pFrameHeader);
+    push_uint32_parameter(nFrameHeaderSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_014_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_014_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_014_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_014_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_014_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_014_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_014_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_014_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_014_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_014_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_014_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_014_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_014_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_014_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_014_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_014_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_014_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_014_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVROverlayError __thiscall IVROverlay_011_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_011_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_011_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_011_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_011_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_011_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_011_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPI);
+    push_ptr_parameter(pColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_011_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_011_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_011_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_011_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_011_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_011_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_011_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_011_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+void __thiscall IVRCompositor_013_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_013_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_013_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_013_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_013_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_013_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_013_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_013_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_013_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_013_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_013_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_013_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_013_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_013_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_013_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_013_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_013_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_013_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_013_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_013_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_013_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_013_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRSystem_011_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_011_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_011_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_011_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_011_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_011_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_011_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_011_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_011_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_011_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_011_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_011_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_011_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_011_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_011_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_011_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_011_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_011_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_011_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_011_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_011_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_011_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_011_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_011_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_011_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_011_PerformanceTestEnableCapture(void *_this, bool bEnable)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bEnable);
+}
+
+void __thiscall IVRSystem_011_PerformanceTestReportFidelityLevelChange(void *_this, int nFidelityLevel)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nFidelityLevel);
+}
+
+EVRApplicationError __thiscall IVRApplications_004_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_004_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_004_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+bool __thiscall IVRApplications_004_CancelApplicationLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_004_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_004_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_004_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_004_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint64_t __thiscall IVRApplications_004_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_004_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_004_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_004_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_004_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBinaryPath);
+    push_ptr_parameter(pchArguments);
+    push_ptr_parameter(pchWorkingDirectory);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_010_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_010_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_010_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_010_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_010_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_010_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_010_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_010_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_010_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_010_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_010_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_010_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_010_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(ppRenderModel);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_004_FreeRenderModel(void *_this, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderModel);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(ppTexture);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_004_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTexture);
+}
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(pD3D11Device);
+    push_ptr_parameter(ppD3D11Texture2D);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_004_FreeTextureD3D11(void *_this, void * pD3D11Texture2D)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11Texture2D);
+}
+
+uint32_t __thiscall IVRRenderModels_004_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unRenderModelIndex);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unRenderModelNameLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_004_GetRenderModelCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentCount(void *_this, const char * pchRenderModelName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unComponentIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameLen);
+    return 0;
+}
+
+uint64_t __thiscall IVRRenderModels_004_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pchComponentRenderModelName);
+    push_uint32_parameter(unComponentRenderModelNameLen);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_004_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pState);
+    push_ptr_parameter(pComponentState);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_004_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_012_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_012_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_012_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_012_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_012_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_012_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_012_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_012_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_012_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_012_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_012_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_012_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_012_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_012_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_012_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_012_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_012_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_012_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_012_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_012_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_012_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_003_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_003_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_003_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_003_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_003_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_003_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint64_t __thiscall IVRApplications_003_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_003_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_003_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_003_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_003_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_003_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_011_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_011_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_011_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_011_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_011_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_011_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_011_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_011_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_011_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_011_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_011_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_011_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_011_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_011_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_011_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_011_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_011_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_011_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_011_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRRenderModels_002_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(ppRenderModel);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_002_FreeRenderModel(void *_this, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderModel);
+}
+
+bool __thiscall IVRRenderModels_002_LoadTexture(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(textureId);
+    push_ptr_parameter(ppTexture);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_002_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTexture);
+}
+
+uint32_t __thiscall IVRRenderModels_002_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unRenderModelIndex);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unRenderModelNameLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_002_GetRenderModelCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentCount(void *_this, const char * pchRenderModelName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unComponentIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameLen);
+    return 0;
+}
+
+uint64_t __thiscall IVRRenderModels_002_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pchComponentRenderModelName);
+    push_uint32_parameter(unComponentRenderModelNameLen);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_002_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ComponentState_t * pComponentState)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pComponentState);
+    return 0;
+}
+
+bool __thiscall IVRRenderModels_002_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_010_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_010_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_010_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_010_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_010_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_010_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_010_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_010_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_010_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_010_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_010_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_010_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_010_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_010_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_010_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_010_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_010_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_010_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_010_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_010_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_010_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_010_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_010_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_010_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_010_PerformanceTestEnableCapture(void *_this, bool bEnable)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bEnable);
+}
+
+void __thiscall IVRSystem_010_PerformanceTestReportFidelityLevelChange(void *_this, int nFidelityLevel)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nFidelityLevel);
+}
+
+EVRApplicationError __thiscall IVRApplications_002_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_002_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_002_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_002_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_002_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_002_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_002_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_002_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_002_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_002_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_002_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_002_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(configFile);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_004_RevertWorkingCopy(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSizeX);
+    push_ptr_parameter(pSizeZ);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingPlayAreaRect(void *_this, HmdQuad_t * rect)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(rect);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatSeatedZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatStandingZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingPlayAreaSize(void *_this, float sizeX, float sizeZ)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(sizeX);
+    push_float_parameter(sizeZ);
+}
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_uint32_parameter(unQuadsCount);
+}
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pMatSeatedZeroPoseToRawTrackingPose);
+}
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pMatStandingZeroPoseToRawTrackingPose);
+}
+
+void __thiscall IVRChaperoneSetup_004_ReloadFromDisk(void *_this, EChaperoneConfigFile configFile)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(configFile);
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pmatSeatedZeroPoseToRawTrackingPose);
+    return 0;
+}
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingWallTagInfo(void *_this, uint8_t * pTagsBuffer, uint32_t unTagCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTagsBuffer);
+    push_uint32_parameter(unTagCount);
+}
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveWallTagInfo(void *_this, uint8_t * pTagsBuffer, uint32_t * punTagCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTagsBuffer);
+    push_ptr_parameter(punTagCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_010_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_010_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_010_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_010_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_010_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_010_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_010_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_010_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_010_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_010_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_010_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_010_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_010_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_010_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_010_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_010_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_010_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_010_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_010_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVROverlayError __thiscall IVROverlay_008_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_008_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_008_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_008_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_008_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_008_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_008_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_008_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+EVROverlayError __thiscall IVROverlay_008_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_008_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_008_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_008_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_008_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_008_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+bool __thiscall IVRTrackedCamera_001_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_GetCameraFirmwareDescription(void *_this, TrackedDeviceIndex_t nDeviceIndex, char * pBuffer, uint32_t nBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pBuffer);
+    push_uint32_parameter(nBufferLen);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_GetCameraFrameDimensions(void *_this, TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(nVideoStreamFormat);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_SetCameraVideoStreamFormat(void *_this, TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_uint32_parameter(nVideoStreamFormat);
+    return 0;
+}
+
+ECameraVideoStreamFormat __thiscall IVRTrackedCamera_001_GetCameraVideoStreamFormat(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_EnableCameraForStreaming(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool bEnable)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_bool_parameter(bEnable);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_StartVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_StopVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_IsVideoStreamActive(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+float __thiscall IVRTrackedCamera_001_GetVideoStreamElapsedTime(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+const CameraVideoStreamFrame_t * __thiscall IVRTrackedCamera_001_GetVideoStreamFrame(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_ReleaseVideoStreamFrame(void *_this, TrackedDeviceIndex_t nDeviceIndex, CameraVideoStreamFrame_t * pFrameImage)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_ptr_parameter(pFrameImage);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_SetAutoExposure(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool bEnable)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_bool_parameter(bEnable);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_PauseVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_ResumeVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_IsVideoStreamPaused(void *_this, TrackedDeviceIndex_t nDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_GetCameraDistortion(void *_this, TrackedDeviceIndex_t nDeviceIndex, float flInputU, float flInputV, float * pflOutputU, float * pflOutputV)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_float_parameter(flInputU);
+    push_float_parameter(flInputV);
+    push_ptr_parameter(pflOutputU);
+    push_ptr_parameter(pflOutputV);
+    return 0;
+}
+
+bool __thiscall IVRTrackedCamera_001_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, float flWidthPixels, float flHeightPixels, float flZNear, float flZFar, HmdMatrix44_t * pProjection)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(nDeviceIndex);
+    push_float_parameter(flWidthPixels);
+    push_float_parameter(flHeightPixels);
+    push_float_parameter(flZNear);
+    push_float_parameter(flZFar);
+    push_ptr_parameter(pProjection);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_009_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_009_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_009_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_009_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_009_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_009_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+float __thiscall IVRCompositor_009_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_009_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_009_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_009_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_009_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_009_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_009_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_009_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_009_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_009_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_009_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_009_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_009_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_009_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_009_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_009_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_009_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+bool __thiscall IVRSystem_009_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_009_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_009_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_009_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_009_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_009_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_009_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_009_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_009_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_009_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_009_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_009_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_009_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_009_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_009_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_009_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_009_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_009_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_009_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+EVROverlayError __thiscall IVROverlay_007_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_007_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_007_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_007_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_007_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_007_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_007_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_007_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+EVROverlayError __thiscall IVROverlay_007_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_007_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_007_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_007_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_006_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_006_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_006_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_006_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_006_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_006_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_006_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_006_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+    push_ptr_parameter(pnAdapterOutputIndex);
+}
+
+bool __thiscall IVRSystem_006_AttachToWindow(void *_this, void * hWnd)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(hWnd);
+    return 0;
+}
+
+void __thiscall IVRSystem_006_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_006_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass(void *_this, TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_006_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+TrackedDeviceClass __thiscall IVRSystem_006_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_006_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_006_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_006_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_006_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_006_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_006_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_006_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_006_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_006_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_006_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_006_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_006_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_006_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+VRFirmwareError __thiscall IVRSystem_006_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_006_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_001_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_001_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_001_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_001_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_001_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_001_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_GetHomeApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_SetHomeApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_001_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_001_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_001_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_001_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+ChaperoneCalibrationState __thiscall IVRChaperone_002_GetCalibrationState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRChaperone_002_GetSoftBoundsInfo(void *_this, ChaperoneSoftBoundsInfo_t * pInfo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pInfo);
+    return 0;
+}
+
+bool __thiscall IVRChaperone_002_GetHardBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pQuadsBuffer);
+    push_ptr_parameter(punQuadsCount);
+    return 0;
+}
+
+bool __thiscall IVRChaperone_002_GetSeatedBoundsInfo(void *_this, ChaperoneSeatedBoundsInfo_t * pInfo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pInfo);
+    return 0;
+}
+
+void __thiscall IVRChaperone_002_ReloadInfo(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRChaperone_002_SetSceneColor(void *_this, HmdColor_t color)
+{
+    push_ptr_parameter(_this);
+    push_HmdColor_parameter(color);
+}
+
+void __thiscall IVRChaperone_002_GetBoundsColor(void *_this, HmdColor_t * pOutputColorArray, int nNumOutputColors)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputColorArray);
+    push_uint32_parameter(nNumOutputColors);
+}
+
+bool __thiscall IVRChaperone_002_AreBoundsVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRChaperone_002_ForceBoundsVisible(void *_this, bool bForce)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bForce);
+}
+
+uint32_t __thiscall IVRCompositor_008_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_SetVSync(void *_this, bool bVSync)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bVSync);
+}
+
+bool __thiscall IVRCompositor_008_GetVSync(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_SetGamma(void *_this, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fGamma);
+}
+
+float __thiscall IVRCompositor_008_GetGamma(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+VRCompositorError __thiscall IVRCompositor_008_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+VRCompositorError __thiscall IVRCompositor_008_Submit(void *_this, Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds, VRSubmitFlags_t nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_008_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_008_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+void __thiscall IVRCompositor_008_SetSkyboxOverride(void *_this, GraphicsAPIConvention eTextureType, void * pFront, void * pBack, void * pLeft, void * pRight, void * pTop, void * pBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pFront);
+    push_ptr_parameter(pBack);
+    push_ptr_parameter(pLeft);
+    push_ptr_parameter(pRight);
+    push_ptr_parameter(pTop);
+    push_ptr_parameter(pBottom);
+}
+
+void __thiscall IVRCompositor_008_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_008_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_008_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_008_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_008_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+TrackingUniverseOrigin __thiscall IVRCompositor_008_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_008_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_008_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_008_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_008_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_008_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+float __thiscall IVRCompositor_008_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_008_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRNotifications_001_GetErrorString(void *_this, NotificationError_t error, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+NotificationError_t __thiscall IVRNotifications_001_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, const char * strType, const char * strText, const char * strCategory, NotificationBitmap * photo, VRNotificationId * notificationId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulUserValue);
+    push_ptr_parameter(strType);
+    push_ptr_parameter(strText);
+    push_ptr_parameter(strCategory);
+    push_ptr_parameter(photo);
+    push_ptr_parameter(notificationId);
+    return 0;
+}
+
+NotificationError_t __thiscall IVRNotifications_001_DismissNotification(void *_this, VRNotificationId notificationId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(notificationId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_005_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_005_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_005_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_005_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_IsFocusOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_005_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_005_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_005_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+VROverlayError __thiscall IVROverlay_005_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_005_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_005_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRRenderModels_001_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pRenderModel);
+    return 0;
+}
+
+void __thiscall IVRRenderModels_001_FreeRenderModel(void *_this, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderModel);
+}
+
+uint32_t __thiscall IVRRenderModels_001_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unRenderModelIndex);
+    push_ptr_parameter(pchRenderModelName);
+    push_uint32_parameter(unRenderModelNameLen);
+    return 0;
+}
+
+uint32_t __thiscall IVRRenderModels_001_GetRenderModelCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_005_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_005_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_005_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_005_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_005_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+    push_ptr_parameter(pnAdapterOutputIndex);
+}
+
+bool __thiscall IVRSystem_005_AttachToWindow(void *_this, void * hWnd)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(hWnd);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_005_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass(void *_this, TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+TrackedDeviceClass __thiscall IVRSystem_005_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_005_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_005_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_005_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_005_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_005_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_005_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_005_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_005_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_005_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_005_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_005_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_005_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_005_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_007_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_007_SetVSync(void *_this, bool bVSync)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bVSync);
+}
+
+bool __thiscall IVRCompositor_007_GetVSync(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_007_SetGamma(void *_this, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fGamma);
+}
+
+float __thiscall IVRCompositor_007_GetGamma(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+VRCompositorError __thiscall IVRCompositor_007_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+VRCompositorError __thiscall IVRCompositor_007_Submit(void *_this, Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    return 0;
+}
+
+void __thiscall IVRCompositor_007_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_007_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+void __thiscall IVRCompositor_007_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_007_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+void __thiscall IVRCompositor_007_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_007_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_007_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_007_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_007_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+TrackingUniverseOrigin __thiscall IVRCompositor_007_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_007_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_007_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_004_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_004_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_004_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_004_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_004_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_004_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_004_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+VROverlayError __thiscall IVROverlay_003_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_003_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_003_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_003_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_003_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_003_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_003_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_003_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+VROverlayError __thiscall IVROverlay_002_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_002_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_002_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureType);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_002_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_002_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_004_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_004_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_004_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_004_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_004_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+    push_ptr_parameter(pnAdapterOutputIndex);
+}
+
+bool __thiscall IVRSystem_004_AttachToWindow(void *_this, void * hWnd)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(hWnd);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_004_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+TrackedDeviceClass __thiscall IVRSystem_004_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_004_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_004_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_004_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_004_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_004_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_004_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_004_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_004_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_004_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_004_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_004_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_004_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_004_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchRequest);
+    push_ptr_parameter(pchResponseBuffer);
+    push_uint32_parameter(unResponseBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_006_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_SetVSync(void *_this, bool bVSync)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bVSync);
+}
+
+bool __thiscall IVRCompositor_006_GetVSync(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_SetGamma(void *_this, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fGamma);
+}
+
+float __thiscall IVRCompositor_006_GetGamma(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_SetGraphicsDevice(void *_this, Compositor_DeviceType eType, void * pDevice)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    push_ptr_parameter(pDevice);
+}
+
+VRCompositorError __thiscall IVRCompositor_006_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+VRCompositorError __thiscall IVRCompositor_006_Submit(void *_this, Hmd_Eye eEye, void * pTexture, VRTextureBounds_t * pBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_006_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_006_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+void __thiscall IVRCompositor_006_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_006_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_006_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_006_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_006_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+TrackingUniverseOrigin __thiscall IVRCompositor_006_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_006_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_006_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_001_GetHighQualityOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_001_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfGamma);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayVisibility(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayVisibility * peOverlayVisibility)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peOverlayVisibility);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayVisibility(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayVisibility eOverlayVisibility)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayVisibility);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unControllerDeviceIndex);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_IsSystemOverlayVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_001_IsActiveSystemOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_SetSystemOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+VROverlayError __thiscall IVROverlay_001_GetSystemOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_003_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+void __thiscall IVRSystem_003_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pnX);
+    push_ptr_parameter(pnY);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_003_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    push_uint32_parameter(eProjType);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+DistortionCoordinates_t *__thiscall IVRSystem_003_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_003_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+    push_ptr_parameter(pnAdapterOutputIndex);
+}
+
+bool __thiscall IVRSystem_003_AttachToWindow(void *_this, void * hWnd)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(hWnd);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_003_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelName);
+    push_ptr_parameter(pRenderModel);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_FreeRenderModel(void *_this, RenderModel_t * pRenderModel)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderModel);
+}
+
+TrackedDeviceClass __thiscall IVRSystem_003_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_003_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_003_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_003_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_003_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_003_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_PollNextEvent(void *_this, VREvent_t * pEvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_003_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_003_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_003_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_003_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_HandleControllerOverlayInteractionAsMouse(void *_this, Compositor_OverlaySettings * overlaySettings, HmdVector2_t vecWindowClientPositionOnScreen, HmdVector2_t vecWindowClientSize, TrackedDeviceIndex_t unControllerDeviceIndex, EVRControllerEventOutputType eOutputType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(overlaySettings);
+    push_HmdVector2_parameter(vecWindowClientPositionOnScreen);
+    push_HmdVector2_parameter(vecWindowClientSize);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(eOutputType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_003_CaptureInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_003_ReleaseInputFocus(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRSystem_003_IsInputFocusCapturedByAnotherProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_005_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_005_SetVSync(void *_this, bool bVSync)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bVSync);
+}
+
+bool __thiscall IVRCompositor_005_GetVSync(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_005_SetGamma(void *_this, float fGamma)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fGamma);
+}
+
+float __thiscall IVRCompositor_005_GetGamma(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_005_SetGraphicsDevice(void *_this, Compositor_DeviceType eType, void * pDevice)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    push_ptr_parameter(pDevice);
+}
+
+void __thiscall IVRCompositor_005_WaitGetPoses(void *_this, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPoseArray);
+    push_uint32_parameter(unPoseArrayCount);
+}
+
+void __thiscall IVRCompositor_005_Submit(void *_this, Hmd_Eye eEye, void * pTexture, Compositor_TextureBounds * pBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+}
+
+void __thiscall IVRCompositor_005_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_005_GetOverlayDefaults(void *_this, Compositor_OverlaySettings * pSettings)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSettings);
+}
+
+void __thiscall IVRCompositor_005_SetOverlay(void *_this, void * pTexture, Compositor_OverlaySettings * pSettings)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pSettings);
+}
+
+void __thiscall IVRCompositor_005_SetOverlayRaw(void *_this, void * buffer, uint32_t width, uint32_t height, uint32_t depth, Compositor_OverlaySettings * pSettings)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(buffer);
+    push_uint32_parameter(width);
+    push_uint32_parameter(height);
+    push_uint32_parameter(depth);
+    push_ptr_parameter(pSettings);
+}
+
+void __thiscall IVRCompositor_005_SetOverlayFromFile(void *_this, const char * pchFilePath, Compositor_OverlaySettings * pSettings)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchFilePath);
+    push_ptr_parameter(pSettings);
+}
+
+void __thiscall IVRCompositor_005_ClearOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_005_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+void __thiscall IVRCompositor_005_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_005_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+void __thiscall IVRCompositor_005_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_005_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_005_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_005_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_005_ComputeOverlayIntersection(void *_this, Compositor_OverlaySettings * pSettings, float fAspectRatio, TrackingUniverseOrigin eOrigin, HmdVector3_t vSource, HmdVector3_t vDirection, HmdVector2_t * pvecIntersectionUV, HmdVector3_t * pvecIntersectionTrackingSpace)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pSettings);
+    push_float_parameter(fAspectRatio);
+    push_uint32_parameter(eOrigin);
+    push_HmdVector3_parameter(vSource);
+    push_HmdVector3_parameter(vDirection);
+    push_ptr_parameter(pvecIntersectionUV);
+    push_ptr_parameter(pvecIntersectionTrackingSpace);
+    return 0;
+}
+
+void __thiscall IVRCompositor_005_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+TrackingUniverseOrigin __thiscall IVRCompositor_005_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
diff --git a/vrclient_x64/tests/capi_thunks_autogen.h b/vrclient_x64/tests/capi_thunks_autogen.h
new file mode 100644
index 00000000..bedf23ef
--- /dev/null
+++ b/vrclient_x64/tests/capi_thunks_autogen.h
@@ -0,0 +1,4904 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+
+#include "cxx.h"
+#include "flatapi.h"
+#include "vrclient_defs.h"
+
+#include "capi_thunks.h"
+
+void test_capi_thunks_IVRSystem_019(void);
+
+void __thiscall IVRSystem_019_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_019_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+
+void __thiscall IVRSystem_019_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_019_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_019_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_019_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_019_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+void __thiscall IVRSystem_019_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
+
+bool __thiscall IVRSystem_019_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_019_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_019_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_019_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_019_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_019_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_019_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_019_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_019_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_019_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_019_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_019_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_019_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_019_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_019_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_019_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_019_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_019_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_019_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_019_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_019_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_019_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_019_IsInputAvailable(void *_this);
+
+bool __thiscall IVRSystem_019_IsSteamVRDrawingControllers(void *_this);
+
+bool __thiscall IVRSystem_019_ShouldApplicationPause(void *_this);
+
+bool __thiscall IVRSystem_019_ShouldApplicationReduceRenderingWork(void *_this);
+
+uint32_t __thiscall IVRSystem_019_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_019_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_019_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_019_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVRApplications_006(void);
+
+EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType);
+
+bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs);
+
+EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
+
+uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this);
+
+void test_capi_thunks_IVRSettings_002(void);
+
+const char * __thiscall IVRSettings_002_GetSettingsErrorNameFromEnum(void *_this, EVRSettingsError eError);
+
+bool __thiscall IVRSettings_002_Sync(void *_this, bool bForce, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_SetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_SetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_SetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_SetString(void *_this, const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError);
+
+bool __thiscall IVRSettings_002_GetBool(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError);
+
+int32_t __thiscall IVRSettings_002_GetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError);
+
+float __thiscall IVRSettings_002_GetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_GetString(void *_this, const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_RemoveSection(void *_this, const char * pchSection, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_002_RemoveKeyInSection(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError);
+
+void test_capi_thunks_IVRChaperone_003(void);
+
+ChaperoneCalibrationState __thiscall IVRChaperone_003_GetCalibrationState(void *_this);
+
+bool __thiscall IVRChaperone_003_GetPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ);
+
+bool __thiscall IVRChaperone_003_GetPlayAreaRect(void *_this, HmdQuad_t * rect);
+
+void __thiscall IVRChaperone_003_ReloadInfo(void *_this);
+
+void __thiscall IVRChaperone_003_SetSceneColor(void *_this, HmdColor_t color);
+
+void __thiscall IVRChaperone_003_GetBoundsColor(void *_this, HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t * pOutputCameraColor);
+
+bool __thiscall IVRChaperone_003_AreBoundsVisible(void *_this);
+
+void __thiscall IVRChaperone_003_ForceBoundsVisible(void *_this, bool bForce);
+
+void test_capi_thunks_IVRChaperoneSetup_005(void);
+
+bool __thiscall IVRChaperoneSetup_005_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile);
+
+void __thiscall IVRChaperoneSetup_005_RevertWorkingCopy(void *_this);
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ);
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingPlayAreaRect(void *_this, HmdQuad_t * rect);
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+
+bool __thiscall IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingPlayAreaSize(void *_this, float sizeX, float sizeZ);
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount);
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_005_ReloadFromDisk(void *_this, EChaperoneConfigFile configFile);
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo(void *_this, uint8_t * pTagsBuffer, uint32_t unTagCount);
+
+bool __thiscall IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo(void *_this, uint8_t * pTagsBuffer, uint32_t * punTagCount);
+
+bool __thiscall IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_005_ExportLiveToBuffer(void *_this, char * pBuffer, uint32_t * pnBufferLength);
+
+bool __thiscall IVRChaperoneSetup_005_ImportFromBufferToWorking(void *_this, const char * pBuffer, uint32_t nImportFlags);
+
+void test_capi_thunks_IVRCompositor_022(void);
+
+void __thiscall IVRCompositor_022_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_022_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_022_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_022_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_022_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_022_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_022_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_022_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_022_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_022_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_022_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_022_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_022_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_022_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_022_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_022_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_022_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_022_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_022_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_022_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_022_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_022_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_022_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_022_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_022_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_022_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_022_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_022_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_022_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_022_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_022_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_022_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_022_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_022_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+void __thiscall IVRCompositor_022_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_022_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_022_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_022_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_022_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+uint32_t __thiscall IVRCompositor_022_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+
+uint32_t __thiscall IVRCompositor_022_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_022_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
+
+EVRCompositorError __thiscall IVRCompositor_022_SubmitExplicitTimingData(void *_this);
+
+void test_capi_thunks_IVRNotifications_002(void);
+
+EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
+
+EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
+
+void test_capi_thunks_IVROverlay_018(void);
+
+EVROverlayError __thiscall IVROverlay_018_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_018_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_018_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_018_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_018_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_018_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+uint32_t __thiscall IVROverlay_018_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_018_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_018_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_018_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_018_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_018_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_018_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_018_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_018_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_018_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_018_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_018_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_018_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_018_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_018_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_018_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_018_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_018_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_018_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_018_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_018_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_018_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_018_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_018_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_018_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_018_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+VRMessageOverlayResponse __thiscall IVROverlay_018_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_018_CloseMessageOverlay(void *_this);
+
+void test_capi_thunks_IVRRenderModels_005(void);
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
+
+void __thiscall IVRRenderModels_005_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
+
+void __thiscall IVRRenderModels_005_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+
+EVRRenderModelError __thiscall IVRRenderModels_005_LoadIntoTextureD3D11_Async(void *_this, TextureID_t textureId, void * pDstTexture);
+
+void __thiscall IVRRenderModels_005_FreeTextureD3D11(void *_this, void * pD3D11Texture2D);
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelCount(void *_this);
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentCount(void *_this, const char * pchRenderModelName);
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+
+uint64_t __thiscall IVRRenderModels_005_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_005_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+
+bool __thiscall IVRRenderModels_005_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_005_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelThumbnailURL(void *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
+
+uint32_t __thiscall IVRRenderModels_005_GetRenderModelOriginalPath(void *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
+
+const char * __thiscall IVRRenderModels_005_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error);
+
+void test_capi_thunks_IVRExtendedDisplay_001(void);
+
+void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+void test_capi_thunks_IVRTrackedCamera_003(void);
+
+const char * __thiscall IVRTrackedCamera_003_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+
+void test_capi_thunks_IVRScreenshots_001(void);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes);
+
+EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
+
+uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename);
+
+void test_capi_thunks_IVRResources_001(void);
+
+uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
+
+uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
+
+void test_capi_thunks_IVRDriverManager_001(void);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
+
+DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
+
+void test_capi_thunks_IVRInput_003(void);
+
+EVRInputError __thiscall IVRInput_003_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
+
+EVRInputError __thiscall IVRInput_003_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_003_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_003_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_003_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
+
+EVRInputError __thiscall IVRInput_003_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize);
+
+EVRInputError __thiscall IVRInput_003_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize);
+
+EVRInputError __thiscall IVRInput_003_GetPoseActionData(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize);
+
+EVRInputError __thiscall IVRInput_003_GetSkeletalActionData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_003_GetSkeletalActionDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
+
+EVRInputError __thiscall IVRInput_003_UncompressSkeletalActionData(void *_this, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_003_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude);
+
+EVRInputError __thiscall IVRInput_003_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
+
+EVRInputError __thiscall IVRInput_003_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize);
+
+EVRInputError __thiscall IVRInput_003_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
+
+EVRInputError __thiscall IVRInput_003_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
+
+EVRInputError __thiscall IVRInput_003_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
+
+void test_capi_thunks_IVRIOBuffer_001(void);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
+
+PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
+
+void test_capi_thunks_IVRClientCore_003(void);
+
+EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
+
+void __thiscall IVRClientCore_003_Cleanup(void *_this);
+
+EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
+
+void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
+
+bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
+
+const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
+
+const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
+
+void test_capi_thunks_IVRSystem_017(void);
+
+void __thiscall IVRSystem_017_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_017_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+
+void __thiscall IVRSystem_017_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_017_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_017_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_017_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_017_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+void __thiscall IVRSystem_017_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
+
+bool __thiscall IVRSystem_017_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_017_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_017_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_017_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_017_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_017_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_017_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_017_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_017_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_017_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_017_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_017_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_017_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_017_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_017_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_017_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_017_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_017_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_017_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_017_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_017_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_017_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_017_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_017_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_017_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_017_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_017_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_017_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_017_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_017_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_017_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_017_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_017_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVROverlay_017(void);
+
+EVROverlayError __thiscall IVROverlay_017_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_017_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_017_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_017_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_017_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_017_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+uint32_t __thiscall IVROverlay_017_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_017_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_017_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_017_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_017_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_017_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_017_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_017_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_017_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_017_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_017_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_017_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_017_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_017_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_017_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_017_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_017_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_017_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_017_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_017_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_017_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_017_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_017_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_017_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_017_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_017_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_017_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+VRMessageOverlayResponse __thiscall IVROverlay_017_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_017_CloseMessageOverlay(void *_this);
+
+void test_capi_thunks_IVRCompositor_021(void);
+
+void __thiscall IVRCompositor_021_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_021_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_021_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_021_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_021_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_021_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_021_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_021_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_021_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_021_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_021_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_021_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_021_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_021_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_021_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_021_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_021_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_021_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_021_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_021_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_021_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_021_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_021_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_021_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_021_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_021_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_021_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_021_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_021_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_021_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_021_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_021_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_021_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_021_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+void __thiscall IVRCompositor_021_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_021_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_021_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_021_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_021_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+uint32_t __thiscall IVRCompositor_021_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+
+uint32_t __thiscall IVRCompositor_021_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_021_SetExplicitTimingMode(void *_this, bool bExplicitTimingMode);
+
+EVRCompositorError __thiscall IVRCompositor_021_SubmitExplicitTimingData(void *_this);
+
+void test_capi_thunks_IVROverlay_016(void);
+
+EVROverlayError __thiscall IVROverlay_016_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_016_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_016_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_016_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_016_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_016_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+uint32_t __thiscall IVROverlay_016_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_016_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_016_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_016_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_016_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_016_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_016_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_016_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_016_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_016_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_016_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_016_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_016_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_016_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_016_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_016_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_016_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_016_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_016_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_016_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_016_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_016_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_016_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_016_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_016_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_016_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_016_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+VRMessageOverlayResponse __thiscall IVROverlay_016_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_016_CloseMessageOverlay(void *_this);
+
+void test_capi_thunks_IVRSystem_016(void);
+
+void __thiscall IVRSystem_016_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_016_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+
+void __thiscall IVRSystem_016_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_016_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_016_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_016_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_016_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+void __thiscall IVRSystem_016_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType);
+
+bool __thiscall IVRSystem_016_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_016_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_016_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_016_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_016_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_016_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_016_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_016_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_016_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_016_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_016_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_016_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_016_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_016_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_016_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_016_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_016_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_016_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_016_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_016_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_016_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_016_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_016_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_016_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_016_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_016_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_016_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_016_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_016_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_016_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_016_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_016_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_016_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVRCompositor_020(void);
+
+void __thiscall IVRCompositor_020_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_020_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_020_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_020_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_020_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_020_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_020_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_020_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_020_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_020_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_020_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_020_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_020_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_020_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_020_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_020_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_020_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_020_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_020_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_020_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_020_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_020_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_020_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_020_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_020_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_020_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_020_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_020_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_020_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_020_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_020_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_020_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_020_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_020_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+void __thiscall IVRCompositor_020_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_020_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_020_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_020_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_020_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+uint32_t __thiscall IVRCompositor_020_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+
+uint32_t __thiscall IVRCompositor_020_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+
+void test_capi_thunks_IVRClientCore_002(void);
+
+EVRInitError __thiscall IVRClientCore_002_Init(void *_this, EVRApplicationType eApplicationType);
+
+void __thiscall IVRClientCore_002_Cleanup(void *_this);
+
+EVRInitError __thiscall IVRClientCore_002_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
+
+void * __thiscall IVRClientCore_002_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
+
+bool __thiscall IVRClientCore_002_BIsHmdPresent(void *_this);
+
+const char * __thiscall IVRClientCore_002_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
+
+const char * __thiscall IVRClientCore_002_GetIDForVRInitError(void *_this, EVRInitError eError);
+
+void test_capi_thunks_IVRSystem_015(void);
+
+void __thiscall IVRSystem_015_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_015_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+
+void __thiscall IVRSystem_015_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_015_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_015_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_015_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_015_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_015_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_015_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_015_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_015_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_015_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_015_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_015_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_015_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_015_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_015_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_015_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_015_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_015_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_015_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_015_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_015_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_015_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_015_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_015_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_015_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_015_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_015_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_015_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_015_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_015_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_015_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_015_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_015_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_015_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_015_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_015_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_015_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_015_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVROverlay_014(void);
+
+EVROverlayError __thiscall IVROverlay_014_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_014_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_014_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_014_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_014_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_014_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_014_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_014_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_014_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_014_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_014_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_014_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_014_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_014_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_014_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_014_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_014_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_014_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_014_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_014_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_014_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_014_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_014_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_014_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_014_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_014_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_014_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_014_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_014_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_014_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_014_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_014_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+VRMessageOverlayResponse __thiscall IVROverlay_014_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void test_capi_thunks_IVRCompositor_019(void);
+
+void __thiscall IVRCompositor_019_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_019_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_019_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_019_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_019_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_019_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_019_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_019_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_019_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_019_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_019_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_019_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_019_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_019_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_019_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_019_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_019_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_019_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_019_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_019_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_019_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_019_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_019_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_019_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_019_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_019_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_019_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_019_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_019_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_019_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_019_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_019_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_019_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_019_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_019_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_019_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_019_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_019_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+uint32_t __thiscall IVRCompositor_019_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+
+uint32_t __thiscall IVRCompositor_019_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+
+void test_capi_thunks_IVRSystem_014(void);
+
+void __thiscall IVRSystem_014_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_014_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_014_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_014_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_014_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_014_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_014_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_014_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_014_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_014_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_014_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_014_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_014_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_014_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_014_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_014_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_014_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_014_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_014_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_014_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_014_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_014_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_014_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_014_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_014_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_014_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_014_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_014_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_014_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_014_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_014_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_014_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_014_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_014_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_014_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_014_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_014_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_014_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_014_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_014_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVRCompositor_018(void);
+
+void __thiscall IVRCompositor_018_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_018_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_018_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_018_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_018_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_018_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_018_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_018_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_018_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_018_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_018_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_018_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_018_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_018_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_018_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_018_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_018_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_018_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_018_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_018_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_018_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_018_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_018_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_018_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_018_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_018_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_018_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_018_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_018_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_018_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_018_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_018_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_018_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_018_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_018_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_018_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_018_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_018_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void test_capi_thunks_IVROverlay_013(void);
+
+EVROverlayError __thiscall IVROverlay_013_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_013_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_013_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_013_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_013_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_013_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_013_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_013_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_013_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_013_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_013_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_013_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_013_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_013_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_013_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_013_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace);
+
+EVROverlayError __thiscall IVROverlay_013_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_013_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_013_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_013_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_013_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_013_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_013_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_013_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_013_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_013_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_013_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_013_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_013_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_013_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_013_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+void test_capi_thunks_IVRSystem_012(void);
+
+void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_012_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_012_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_012_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_012_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_012_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_012_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_012_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_012_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_012_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_012_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_012_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_012_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_012_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_012_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_012_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_012_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_012_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_012_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_012_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_012_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_012_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_012_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_012_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_012_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_012_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_012_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_012_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_012_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_012_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_012_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_012_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_012_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_012_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_012_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_012_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_012_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_012_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_012_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_012_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVRCompositor_016(void);
+
+void __thiscall IVRCompositor_016_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_016_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_016_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_016_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_016_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_016_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_016_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_016_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_016_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_016_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_016_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_016_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_016_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_016_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_016_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_016_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_016_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_016_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_016_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_016_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_016_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_016_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_016_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_016_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_016_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_016_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_016_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_016_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_016_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_016_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_016_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_016_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_016_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_016_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_016_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void test_capi_thunks_IVRSettings_001(void);
+
+const char * __thiscall IVRSettings_001_GetSettingsErrorNameFromEnum(void *_this, EVRSettingsError eError);
+
+bool __thiscall IVRSettings_001_Sync(void *_this, bool bForce, EVRSettingsError * peError);
+
+bool __thiscall IVRSettings_001_GetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bDefaultValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_SetBool(void *_this, const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError);
+
+int32_t __thiscall IVRSettings_001_GetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nDefaultValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_SetInt32(void *_this, const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError);
+
+float __thiscall IVRSettings_001_GetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flDefaultValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_SetFloat(void *_this, const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_GetString(void *_this, const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, const char * pchDefaultValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_SetString(void *_this, const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_RemoveSection(void *_this, const char * pchSection, EVRSettingsError * peError);
+
+void __thiscall IVRSettings_001_RemoveKeyInSection(void *_this, const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError);
+
+void test_capi_thunks_IVRApplications_005(void);
+
+EVRApplicationError __thiscall IVRApplications_005_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_005_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_005_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_005_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_005_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_005_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys);
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+bool __thiscall IVRApplications_005_CancelApplicationLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_005_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_005_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_005_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_005_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_005_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+uint64_t __thiscall IVRApplications_005_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_005_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_005_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_005_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_005_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_005_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_005_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_005_IsQuitUserPromptRequested(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_005_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
+
+void test_capi_thunks_IVRCompositor_015(void);
+
+void __thiscall IVRCompositor_015_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_015_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_015_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_015_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_015_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_015_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_015_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_015_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_015_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_015_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_015_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_015_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_015_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_015_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_015_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_015_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_015_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_015_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_015_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_015_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_015_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_015_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_015_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_015_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_015_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_015_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_015_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_015_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_015_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_015_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_015_RequestScreenshot(void *_this, EVRScreenshotType type, const char * pchDestinationFileName, const char * pchVRDestinationFileName);
+
+EVRScreenshotType __thiscall IVRCompositor_015_GetCurrentScreenshotType(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_015_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_015_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_015_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_015_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_015_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void test_capi_thunks_IVROverlay_012(void);
+
+EVROverlayError __thiscall IVROverlay_012_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_012_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_012_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_012_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_012_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_012_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_012_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_012_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_012_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_012_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_012_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_012_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_012_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_012_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_012_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_012_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_012_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace);
+
+EVROverlayError __thiscall IVROverlay_012_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_012_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_012_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_012_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_012_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_012_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_012_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_012_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_012_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_012_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_012_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_012_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_012_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_012_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_012_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+void test_capi_thunks_IVRTrackedCamera_002(void);
+
+const char * __thiscall IVRTrackedCamera_002_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraIntrinisics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_002_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+void test_capi_thunks_IVRCompositor_014(void);
+
+void __thiscall IVRCompositor_014_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_014_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_014_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_014_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_014_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_014_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_014_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_014_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_014_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_014_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_014_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_014_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_014_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_014_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_014_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_014_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_014_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_014_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_014_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_014_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_014_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_014_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_014_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_014_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_014_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_014_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_014_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_014_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_014_SuspendRendering(void *_this, bool bSuspend);
+
+void test_capi_thunks_IVROverlay_011(void);
+
+EVROverlayError __thiscall IVROverlay_011_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_011_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_011_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_011_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_011_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_011_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_011_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_011_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_011_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_011_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_011_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_011_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_011_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_011_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_011_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_011_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_011_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_011_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace);
+
+EVROverlayError __thiscall IVROverlay_011_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_011_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_011_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_011_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_011_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_011_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_011_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_011_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_011_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_011_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_011_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_011_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_011_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_011_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+void test_capi_thunks_IVRCompositor_013(void);
+
+void __thiscall IVRCompositor_013_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_013_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_013_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_013_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_013_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_013_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_013_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_013_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_013_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_013_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_013_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_013_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_013_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_013_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_013_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_013_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_013_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_013_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_013_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_013_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_013_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_013_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_013_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_013_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_013_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_013_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_013_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void test_capi_thunks_IVRSystem_011(void);
+
+void __thiscall IVRSystem_011_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_011_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_011_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_011_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_011_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_011_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_011_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_011_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_011_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_011_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_011_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_011_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_011_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_011_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_011_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_011_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_011_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_011_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_011_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_011_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_011_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_011_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_011_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_011_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_011_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_011_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_011_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_011_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_011_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_011_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_011_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_011_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_011_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_011_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_011_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_011_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_011_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_011_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_011_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_011_AcknowledgeQuit_UserPrompt(void *_this);
+
+void __thiscall IVRSystem_011_PerformanceTestEnableCapture(void *_this, bool bEnable);
+
+void __thiscall IVRSystem_011_PerformanceTestReportFidelityLevelChange(void *_this, int nFidelityLevel);
+
+void test_capi_thunks_IVRApplications_004(void);
+
+EVRApplicationError __thiscall IVRApplications_004_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_004_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_004_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_004_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_004_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_004_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+bool __thiscall IVRApplications_004_CancelApplicationLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_004_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_004_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_004_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_004_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_004_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+uint64_t __thiscall IVRApplications_004_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_004_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_004_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_004_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_004_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_004_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_004_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_004_IsQuitUserPromptRequested(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_004_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
+
+void test_capi_thunks_IVROverlay_010(void);
+
+EVROverlayError __thiscall IVROverlay_010_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_010_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_010_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_010_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_010_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_010_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_010_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_010_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_010_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_010_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_010_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_010_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_010_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_010_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_010_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_010_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_010_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_010_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_010_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_010_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_010_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_010_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_010_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_010_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_010_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_010_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_010_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_010_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_010_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_010_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+void test_capi_thunks_IVRRenderModels_004(void);
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
+
+void __thiscall IVRRenderModels_004_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
+
+void __thiscall IVRRenderModels_004_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
+
+EVRRenderModelError __thiscall IVRRenderModels_004_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+
+void __thiscall IVRRenderModels_004_FreeTextureD3D11(void *_this, void * pD3D11Texture2D);
+
+uint32_t __thiscall IVRRenderModels_004_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_004_GetRenderModelCount(void *_this);
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentCount(void *_this, const char * pchRenderModelName);
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+
+uint64_t __thiscall IVRRenderModels_004_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_004_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+
+bool __thiscall IVRRenderModels_004_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_004_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+void test_capi_thunks_IVRCompositor_012(void);
+
+void __thiscall IVRCompositor_012_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_012_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_012_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_012_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_012_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_012_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_012_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_012_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_012_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_012_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_012_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_012_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_012_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_012_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_012_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_012_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_012_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_012_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_012_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_012_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_012_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_012_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_012_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_012_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_012_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_012_ShouldAppRenderWithLowResources(void *_this);
+
+void test_capi_thunks_IVRApplications_003(void);
+
+EVRApplicationError __thiscall IVRApplications_003_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_003_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_003_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_003_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_003_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_003_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_003_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_003_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_003_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_003_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_003_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_003_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_003_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+uint64_t __thiscall IVRApplications_003_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_003_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_003_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_003_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_003_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_003_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_003_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_003_IsQuitUserPromptRequested(void *_this);
+
+void test_capi_thunks_IVRCompositor_011(void);
+
+void __thiscall IVRCompositor_011_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_011_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_011_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_011_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_011_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_011_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_011_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_011_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_011_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_011_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_011_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_011_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_011_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_011_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_011_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_011_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_011_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_011_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_011_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_011_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_011_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_011_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_011_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_011_CompositorDumpImages(void *_this);
+
+void test_capi_thunks_IVRRenderModels_002(void);
+
+bool __thiscall IVRRenderModels_002_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
+
+void __thiscall IVRRenderModels_002_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+bool __thiscall IVRRenderModels_002_LoadTexture(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
+
+void __thiscall IVRRenderModels_002_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
+
+uint32_t __thiscall IVRRenderModels_002_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_002_GetRenderModelCount(void *_this);
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentCount(void *_this, const char * pchRenderModelName);
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+
+uint64_t __thiscall IVRRenderModels_002_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_002_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+
+bool __thiscall IVRRenderModels_002_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_002_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+void test_capi_thunks_IVRSystem_010(void);
+
+void __thiscall IVRSystem_010_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_010_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_010_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_010_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_010_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_010_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_010_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_010_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_010_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_010_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_010_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_010_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_010_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_010_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_010_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_010_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_010_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_010_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_010_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_010_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_010_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_010_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_010_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_010_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_010_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_010_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_010_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_010_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_010_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_010_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_010_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_010_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_010_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_010_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_010_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_010_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_010_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_010_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_010_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_010_AcknowledgeQuit_UserPrompt(void *_this);
+
+void __thiscall IVRSystem_010_PerformanceTestEnableCapture(void *_this, bool bEnable);
+
+void __thiscall IVRSystem_010_PerformanceTestReportFidelityLevelChange(void *_this, int nFidelityLevel);
+
+void test_capi_thunks_IVRApplications_002(void);
+
+EVRApplicationError __thiscall IVRApplications_002_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_002_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_002_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_002_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_002_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_002_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_002_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_002_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_002_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_002_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_002_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_002_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_002_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_002_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_002_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_002_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_002_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_002_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_002_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_002_IsQuitUserPromptRequested(void *_this);
+
+void test_capi_thunks_IVRChaperoneSetup_004(void);
+
+bool __thiscall IVRChaperoneSetup_004_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile);
+
+void __thiscall IVRChaperoneSetup_004_RevertWorkingCopy(void *_this);
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingPlayAreaSize(void *_this, float * pSizeX, float * pSizeZ);
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingPlayAreaRect(void *_this, HmdQuad_t * rect);
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+
+bool __thiscall IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingPlayAreaSize(void *_this, float sizeX, float sizeZ);
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount);
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_004_ReloadFromDisk(void *_this, EChaperoneConfigFile configFile);
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose(void *_this, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+
+void __thiscall IVRChaperoneSetup_004_SetWorkingWallTagInfo(void *_this, uint8_t * pTagsBuffer, uint32_t unTagCount);
+
+bool __thiscall IVRChaperoneSetup_004_GetLiveWallTagInfo(void *_this, uint8_t * pTagsBuffer, uint32_t * punTagCount);
+
+void test_capi_thunks_IVRCompositor_010(void);
+
+void __thiscall IVRCompositor_010_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_010_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_010_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_010_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_010_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_010_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_010_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_010_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_010_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_010_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_010_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_010_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_010_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_010_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_010_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_010_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_010_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_010_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_010_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_010_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_010_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_010_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_010_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_010_CompositorDumpImages(void *_this);
+
+void test_capi_thunks_IVROverlay_008(void);
+
+EVROverlayError __thiscall IVROverlay_008_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_008_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_008_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_008_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_008_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_008_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_008_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_008_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_008_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_008_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_008_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_008_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_008_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_008_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_008_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_008_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_008_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_008_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_008_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_008_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_008_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_008_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_008_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+EVROverlayError __thiscall IVROverlay_008_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_008_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_008_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_008_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_008_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_008_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+void test_capi_thunks_IVRTrackedCamera_001(void);
+
+bool __thiscall IVRTrackedCamera_001_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_GetCameraFirmwareDescription(void *_this, TrackedDeviceIndex_t nDeviceIndex, char * pBuffer, uint32_t nBufferLen);
+
+bool __thiscall IVRTrackedCamera_001_GetCameraFrameDimensions(void *_this, TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat, uint32_t * pWidth, uint32_t * pHeight);
+
+bool __thiscall IVRTrackedCamera_001_SetCameraVideoStreamFormat(void *_this, TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat);
+
+ECameraVideoStreamFormat __thiscall IVRTrackedCamera_001_GetCameraVideoStreamFormat(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_EnableCameraForStreaming(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool bEnable);
+
+bool __thiscall IVRTrackedCamera_001_StartVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_StopVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_IsVideoStreamActive(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+float __thiscall IVRTrackedCamera_001_GetVideoStreamElapsedTime(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+const CameraVideoStreamFrame_t * __thiscall IVRTrackedCamera_001_GetVideoStreamFrame(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_ReleaseVideoStreamFrame(void *_this, TrackedDeviceIndex_t nDeviceIndex, CameraVideoStreamFrame_t * pFrameImage);
+
+bool __thiscall IVRTrackedCamera_001_SetAutoExposure(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool bEnable);
+
+bool __thiscall IVRTrackedCamera_001_PauseVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_ResumeVideoStream(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_IsVideoStreamPaused(void *_this, TrackedDeviceIndex_t nDeviceIndex);
+
+bool __thiscall IVRTrackedCamera_001_GetCameraDistortion(void *_this, TrackedDeviceIndex_t nDeviceIndex, float flInputU, float flInputV, float * pflOutputU, float * pflOutputV);
+
+bool __thiscall IVRTrackedCamera_001_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, float flWidthPixels, float flHeightPixels, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+void test_capi_thunks_IVRCompositor_009(void);
+
+void __thiscall IVRCompositor_009_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_009_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_009_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_009_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_009_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_009_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_009_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_009_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+float __thiscall IVRCompositor_009_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_009_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_009_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_009_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_009_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_009_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_009_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_009_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_009_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_009_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_009_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_009_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_009_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_009_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_009_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_009_CompositorDumpImages(void *_this);
+
+void test_capi_thunks_IVRSystem_009(void);
+
+void __thiscall IVRSystem_009_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_009_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_009_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_009_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_009_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_009_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_009_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+bool __thiscall IVRSystem_009_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_009_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_009_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_009_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_009_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_009_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+ETrackedDeviceClass __thiscall IVRSystem_009_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_009_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_009_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_009_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_009_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_009_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_009_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_009_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_009_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_009_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_009_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_009_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_009_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_009_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_009_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_009_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_009_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_009_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_009_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_009_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_009_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_009_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+EVRFirmwareError __thiscall IVRSystem_009_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_009_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_009_AcknowledgeQuit_UserPrompt(void *_this);
+
+void test_capi_thunks_IVROverlay_007(void);
+
+EVROverlayError __thiscall IVROverlay_007_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_007_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_007_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_007_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_007_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_007_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_007_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_007_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_007_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_007_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_007_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_007_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_007_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_007_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_007_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_007_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_007_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_007_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_007_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_007_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_007_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_007_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_007_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+EVROverlayError __thiscall IVROverlay_007_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_007_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_007_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_007_HideKeyboard(void *_this);
+
+void test_capi_thunks_IVRSystem_006(void);
+
+void __thiscall IVRSystem_006_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_006_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_006_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_006_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_006_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_006_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_006_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_006_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_006_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+bool __thiscall IVRSystem_006_AttachToWindow(void *_this, void * hWnd);
+
+void __thiscall IVRSystem_006_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_006_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass(void *_this, TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_006_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+TrackedDeviceClass __thiscall IVRSystem_006_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_006_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_006_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+float __thiscall IVRSystem_006_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_006_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_006_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_006_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_006_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_006_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error);
+
+bool __thiscall IVRSystem_006_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_006_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_006_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_006_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_006_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_006_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_006_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_006_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_006_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_006_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_006_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_006_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_006_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+VRFirmwareError __thiscall IVRSystem_006_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_006_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_006_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void test_capi_thunks_IVRApplications_001(void);
+
+EVRApplicationError __thiscall IVRApplications_001_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_001_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_001_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_001_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_001_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_001_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_001_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_001_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_001_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_001_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_001_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_001_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_001_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_001_GetHomeApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_001_SetHomeApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_001_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_001_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_001_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_001_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_001_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_001_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+void test_capi_thunks_IVRChaperone_002(void);
+
+ChaperoneCalibrationState __thiscall IVRChaperone_002_GetCalibrationState(void *_this);
+
+bool __thiscall IVRChaperone_002_GetSoftBoundsInfo(void *_this, ChaperoneSoftBoundsInfo_t * pInfo);
+
+bool __thiscall IVRChaperone_002_GetHardBoundsInfo(void *_this, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+
+bool __thiscall IVRChaperone_002_GetSeatedBoundsInfo(void *_this, ChaperoneSeatedBoundsInfo_t * pInfo);
+
+void __thiscall IVRChaperone_002_ReloadInfo(void *_this);
+
+void __thiscall IVRChaperone_002_SetSceneColor(void *_this, HmdColor_t color);
+
+void __thiscall IVRChaperone_002_GetBoundsColor(void *_this, HmdColor_t * pOutputColorArray, int nNumOutputColors);
+
+bool __thiscall IVRChaperone_002_AreBoundsVisible(void *_this);
+
+void __thiscall IVRChaperone_002_ForceBoundsVisible(void *_this, bool bForce);
+
+void test_capi_thunks_IVRCompositor_008(void);
+
+uint32_t __thiscall IVRCompositor_008_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_008_SetVSync(void *_this, bool bVSync);
+
+bool __thiscall IVRCompositor_008_GetVSync(void *_this);
+
+void __thiscall IVRCompositor_008_SetGamma(void *_this, float fGamma);
+
+float __thiscall IVRCompositor_008_GetGamma(void *_this);
+
+VRCompositorError __thiscall IVRCompositor_008_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+VRCompositorError __thiscall IVRCompositor_008_Submit(void *_this, Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds, VRSubmitFlags_t nSubmitFlags);
+
+void __thiscall IVRCompositor_008_ClearLastSubmittedFrame(void *_this);
+
+bool __thiscall IVRCompositor_008_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+void __thiscall IVRCompositor_008_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_008_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+void __thiscall IVRCompositor_008_SetSkyboxOverride(void *_this, GraphicsAPIConvention eTextureType, void * pFront, void * pBack, void * pLeft, void * pRight, void * pTop, void * pBottom);
+
+void __thiscall IVRCompositor_008_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_008_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_008_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_008_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_008_IsFullscreen(void *_this);
+
+void __thiscall IVRCompositor_008_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin);
+
+TrackingUniverseOrigin __thiscall IVRCompositor_008_GetTrackingSpace(void *_this);
+
+uint32_t __thiscall IVRCompositor_008_GetCurrentSceneFocusProcess(void *_this);
+
+bool __thiscall IVRCompositor_008_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_008_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_008_HideMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_008_CompositorDumpImages(void *_this);
+
+float __thiscall IVRCompositor_008_GetFrameTimeRemaining(void *_this);
+
+uint32_t __thiscall IVRCompositor_008_GetLastFrameRenderer(void *_this);
+
+void test_capi_thunks_IVRNotifications_001(void);
+
+uint32_t __thiscall IVRNotifications_001_GetErrorString(void *_this, NotificationError_t error, char * pchBuffer, uint32_t unBufferSize);
+
+NotificationError_t __thiscall IVRNotifications_001_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, const char * strType, const char * strText, const char * strCategory, NotificationBitmap * photo, VRNotificationId * notificationId);
+
+NotificationError_t __thiscall IVRNotifications_001_DismissNotification(void *_this, VRNotificationId notificationId);
+
+void test_capi_thunks_IVROverlay_005(void);
+
+VROverlayError __thiscall IVROverlay_005_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_005_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_005_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_005_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_005_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_005_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_005_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_005_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+VROverlayError __thiscall IVROverlay_005_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_005_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_005_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+bool __thiscall IVROverlay_005_IsFocusOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture);
+
+VROverlayError __thiscall IVROverlay_005_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+VROverlayError __thiscall IVROverlay_005_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+VROverlayError __thiscall IVROverlay_005_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_005_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_005_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_005_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+VROverlayError __thiscall IVROverlay_005_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_005_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+VROverlayError __thiscall IVROverlay_005_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode);
+
+uint32_t __thiscall IVROverlay_005_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_005_HideKeyboard(void *_this);
+
+void test_capi_thunks_IVRRenderModels_001(void);
+
+bool __thiscall IVRRenderModels_001_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t * pRenderModel);
+
+void __thiscall IVRRenderModels_001_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+uint32_t __thiscall IVRRenderModels_001_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_001_GetRenderModelCount(void *_this);
+
+void test_capi_thunks_IVRSystem_005(void);
+
+void __thiscall IVRSystem_005_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_005_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_005_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_005_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_005_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_005_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_005_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_005_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_005_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+bool __thiscall IVRSystem_005_AttachToWindow(void *_this, void * hWnd);
+
+void __thiscall IVRSystem_005_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_005_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass(void *_this, TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+TrackedDeviceClass __thiscall IVRSystem_005_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_005_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_005_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+float __thiscall IVRSystem_005_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_005_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_005_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_005_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_005_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_005_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error);
+
+bool __thiscall IVRSystem_005_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_005_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_005_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_005_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_005_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_005_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_005_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_005_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_005_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_005_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_005_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_005_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_005_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+void test_capi_thunks_IVRCompositor_007(void);
+
+uint32_t __thiscall IVRCompositor_007_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_007_SetVSync(void *_this, bool bVSync);
+
+bool __thiscall IVRCompositor_007_GetVSync(void *_this);
+
+void __thiscall IVRCompositor_007_SetGamma(void *_this, float fGamma);
+
+float __thiscall IVRCompositor_007_GetGamma(void *_this);
+
+VRCompositorError __thiscall IVRCompositor_007_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+VRCompositorError __thiscall IVRCompositor_007_Submit(void *_this, Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds);
+
+void __thiscall IVRCompositor_007_ClearLastSubmittedFrame(void *_this);
+
+bool __thiscall IVRCompositor_007_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+void __thiscall IVRCompositor_007_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_007_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+void __thiscall IVRCompositor_007_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_007_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_007_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_007_IsFullscreen(void *_this);
+
+void __thiscall IVRCompositor_007_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin);
+
+TrackingUniverseOrigin __thiscall IVRCompositor_007_GetTrackingSpace(void *_this);
+
+uint32_t __thiscall IVRCompositor_007_GetCurrentSceneFocusProcess(void *_this);
+
+bool __thiscall IVRCompositor_007_CanRenderScene(void *_this);
+
+void test_capi_thunks_IVROverlay_004(void);
+
+VROverlayError __thiscall IVROverlay_004_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_004_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_004_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_004_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_004_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_004_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_004_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_004_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+VROverlayError __thiscall IVROverlay_004_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_004_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_004_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture);
+
+VROverlayError __thiscall IVROverlay_004_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+VROverlayError __thiscall IVROverlay_004_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+VROverlayError __thiscall IVROverlay_004_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_004_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_004_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_004_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+VROverlayError __thiscall IVROverlay_004_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_004_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+void test_capi_thunks_IVROverlay_003(void);
+
+VROverlayError __thiscall IVROverlay_003_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_003_GetHighQualityOverlay(void *_this);
+
+uint32_t __thiscall IVROverlay_003_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_003_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_003_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_003_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_003_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_003_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+VROverlayError __thiscall IVROverlay_003_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_003_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_003_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture);
+
+VROverlayError __thiscall IVROverlay_003_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+VROverlayError __thiscall IVROverlay_003_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+VROverlayError __thiscall IVROverlay_003_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_003_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_003_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_003_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+VROverlayError __thiscall IVROverlay_003_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_003_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+void test_capi_thunks_IVROverlay_002(void);
+
+VROverlayError __thiscall IVROverlay_002_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_002_GetHighQualityOverlay(void *_this);
+
+const char * __thiscall IVROverlay_002_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_002_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_002_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_002_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+VROverlayError __thiscall IVROverlay_002_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_002_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_002_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture);
+
+VROverlayError __thiscall IVROverlay_002_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+VROverlayError __thiscall IVROverlay_002_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+VROverlayError __thiscall IVROverlay_002_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_002_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_002_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_002_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+VROverlayError __thiscall IVROverlay_002_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void test_capi_thunks_IVRSystem_004(void);
+
+void __thiscall IVRSystem_004_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_004_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_004_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_004_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_004_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_004_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_004_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_004_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_004_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+bool __thiscall IVRSystem_004_AttachToWindow(void *_this, void * hWnd);
+
+void __thiscall IVRSystem_004_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_004_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+TrackedDeviceClass __thiscall IVRSystem_004_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_004_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_004_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+float __thiscall IVRSystem_004_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_004_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_004_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_004_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_004_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_004_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error);
+
+bool __thiscall IVRSystem_004_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_004_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_004_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_004_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_004_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_004_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_004_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_004_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_004_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_004_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_004_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_004_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+uint32_t __thiscall IVRSystem_004_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+
+void test_capi_thunks_IVRCompositor_006(void);
+
+uint32_t __thiscall IVRCompositor_006_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_006_SetVSync(void *_this, bool bVSync);
+
+bool __thiscall IVRCompositor_006_GetVSync(void *_this);
+
+void __thiscall IVRCompositor_006_SetGamma(void *_this, float fGamma);
+
+float __thiscall IVRCompositor_006_GetGamma(void *_this);
+
+void __thiscall IVRCompositor_006_SetGraphicsDevice(void *_this, Compositor_DeviceType eType, void * pDevice);
+
+VRCompositorError __thiscall IVRCompositor_006_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+VRCompositorError __thiscall IVRCompositor_006_Submit(void *_this, Hmd_Eye eEye, void * pTexture, VRTextureBounds_t * pBounds);
+
+void __thiscall IVRCompositor_006_ClearLastSubmittedFrame(void *_this);
+
+bool __thiscall IVRCompositor_006_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+void __thiscall IVRCompositor_006_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_006_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+void __thiscall IVRCompositor_006_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_006_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_006_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_006_IsFullscreen(void *_this);
+
+void __thiscall IVRCompositor_006_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin);
+
+TrackingUniverseOrigin __thiscall IVRCompositor_006_GetTrackingSpace(void *_this);
+
+uint32_t __thiscall IVRCompositor_006_GetCurrentSceneFocusProcess(void *_this);
+
+bool __thiscall IVRCompositor_006_CanRenderScene(void *_this);
+
+void test_capi_thunks_IVROverlay_001(void);
+
+VROverlayError __thiscall IVROverlay_001_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_001_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_001_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_001_SetHighQualityOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_001_GetHighQualityOverlay(void *_this);
+
+const char * __thiscall IVROverlay_001_GetOverlayErrorNameFromEnum(void *_this, VROverlayError error);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float fGamma);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayGamma(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfGamma);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayVisibility(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayVisibility * peOverlayVisibility);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayVisibility(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayVisibility eOverlayVisibility);
+
+VROverlayError __thiscall IVROverlay_001_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_001_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_001_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_001_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+VROverlayError __thiscall IVROverlay_001_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_001_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_001_HandleControllerOverlayInteractionAsMouse(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void * pTexture);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+VROverlayError __thiscall IVROverlay_001_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+bool __thiscall IVROverlay_001_IsSystemOverlayVisible(void *_this);
+
+bool __thiscall IVROverlay_001_IsActiveSystemOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayError __thiscall IVROverlay_001_SetSystemOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+VROverlayError __thiscall IVROverlay_001_GetSystemOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void test_capi_thunks_IVRSystem_003(void);
+
+void __thiscall IVRSystem_003_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_003_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRSystem_003_GetEyeOutputViewport(void *_this, Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_003_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType);
+
+void __thiscall IVRSystem_003_GetProjectionRaw(void *_this, Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+DistortionCoordinates_t *__thiscall IVRSystem_003_ComputeDistortion(void *_this, DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV);
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_003_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_003_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_003_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+bool __thiscall IVRSystem_003_AttachToWindow(void *_this, void * hWnd);
+
+void __thiscall IVRSystem_003_GetDeviceToAbsoluteTrackingPose(void *_this, TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_003_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+bool __thiscall IVRSystem_003_LoadRenderModel(void *_this, const char * pchRenderModelName, RenderModel_t * pRenderModel);
+
+void __thiscall IVRSystem_003_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+TrackedDeviceClass __thiscall IVRSystem_003_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_003_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_003_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+float __thiscall IVRSystem_003_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_003_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_003_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_003_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_003_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_003_GetPropErrorNameFromEnum(void *_this, TrackedPropertyError error);
+
+bool __thiscall IVRSystem_003_PollNextEvent(void *_this, VREvent_t * pEvent);
+
+bool __thiscall IVRSystem_003_PollNextEventWithPose(void *_this, TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_003_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_003_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, Hmd_Eye eEye);
+
+bool __thiscall IVRSystem_003_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState);
+
+bool __thiscall IVRSystem_003_GetControllerStateWithPose(void *_this, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_003_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_003_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_003_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_003_HandleControllerOverlayInteractionAsMouse(void *_this, Compositor_OverlaySettings * overlaySettings, HmdVector2_t vecWindowClientPositionOnScreen, HmdVector2_t vecWindowClientSize, TrackedDeviceIndex_t unControllerDeviceIndex, EVRControllerEventOutputType eOutputType);
+
+bool __thiscall IVRSystem_003_CaptureInputFocus(void *_this);
+
+void __thiscall IVRSystem_003_ReleaseInputFocus(void *_this);
+
+bool __thiscall IVRSystem_003_IsInputFocusCapturedByAnotherProcess(void *_this);
+
+void test_capi_thunks_IVRCompositor_005(void);
+
+uint32_t __thiscall IVRCompositor_005_GetLastError(void *_this, char * pchBuffer, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_005_SetVSync(void *_this, bool bVSync);
+
+bool __thiscall IVRCompositor_005_GetVSync(void *_this);
+
+void __thiscall IVRCompositor_005_SetGamma(void *_this, float fGamma);
+
+float __thiscall IVRCompositor_005_GetGamma(void *_this);
+
+void __thiscall IVRCompositor_005_SetGraphicsDevice(void *_this, Compositor_DeviceType eType, void * pDevice);
+
+void __thiscall IVRCompositor_005_WaitGetPoses(void *_this, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
+
+void __thiscall IVRCompositor_005_Submit(void *_this, Hmd_Eye eEye, void * pTexture, Compositor_TextureBounds * pBounds);
+
+void __thiscall IVRCompositor_005_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_005_GetOverlayDefaults(void *_this, Compositor_OverlaySettings * pSettings);
+
+void __thiscall IVRCompositor_005_SetOverlay(void *_this, void * pTexture, Compositor_OverlaySettings * pSettings);
+
+void __thiscall IVRCompositor_005_SetOverlayRaw(void *_this, void * buffer, uint32_t width, uint32_t height, uint32_t depth, Compositor_OverlaySettings * pSettings);
+
+void __thiscall IVRCompositor_005_SetOverlayFromFile(void *_this, const char * pchFilePath, Compositor_OverlaySettings * pSettings);
+
+void __thiscall IVRCompositor_005_ClearOverlay(void *_this);
+
+bool __thiscall IVRCompositor_005_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+void __thiscall IVRCompositor_005_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_005_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+void __thiscall IVRCompositor_005_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_005_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_005_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_005_IsFullscreen(void *_this);
+
+bool __thiscall IVRCompositor_005_ComputeOverlayIntersection(void *_this, Compositor_OverlaySettings * pSettings, float fAspectRatio, TrackingUniverseOrigin eOrigin, HmdVector3_t vSource, HmdVector3_t vDirection, HmdVector2_t * pvecIntersectionUV, HmdVector3_t * pvecIntersectionTrackingSpace);
+
+void __thiscall IVRCompositor_005_SetTrackingSpace(void *_this, TrackingUniverseOrigin eOrigin);
+
+TrackingUniverseOrigin __thiscall IVRCompositor_005_GetTrackingSpace(void *_this);
diff --git a/vrclient_x64/tests/capi_thunks_tests_autogen.c b/vrclient_x64/tests/capi_thunks_tests_autogen.c
new file mode 100644
index 00000000..4ab3a157
--- /dev/null
+++ b/vrclient_x64/tests/capi_thunks_tests_autogen.c
@@ -0,0 +1,21808 @@
+/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+void test_capi_thunks_IVRSystem_019(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_019_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_019_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_019_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_019_GetProjectionMatrix", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_019_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_019_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_019_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_019_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_019_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_019_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_019_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_019_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetOutputDevice, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetOutputDevice((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetOutputDevice", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetOutputDevice", (void *)1);
+    check_uint32_parameter("IVRSystem_019_GetOutputDevice", 2);
+    check_ptr_parameter("IVRSystem_019_GetOutputDevice", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_019_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_019_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_019_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_019_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_019_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_019_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_019_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_019_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_019_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_019_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_019_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_019_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_019_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
+    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 2);
+    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 3);
+    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", (void *)4);
+    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 5);
+    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_019_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_019_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_019_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_019_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_019_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_019_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_019_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_019_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_019_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_019_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_019_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_019_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_019_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_019_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_019_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_019_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_019_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_019_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_019_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_019_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_IsInputAvailable, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_IsInputAvailable)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_IsInputAvailable();
+    check_ptr_parameter("IVRSystem_019_IsInputAvailable", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_IsSteamVRDrawingControllers)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_IsSteamVRDrawingControllers();
+    check_ptr_parameter("IVRSystem_019_IsSteamVRDrawingControllers", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_ShouldApplicationPause, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_ShouldApplicationPause)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_ShouldApplicationPause();
+    check_ptr_parameter("IVRSystem_019_ShouldApplicationPause", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_019_ShouldApplicationReduceRenderingWork)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_ShouldApplicationReduceRenderingWork();
+    check_ptr_parameter("IVRSystem_019_ShouldApplicationReduceRenderingWork", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_019_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_019_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_019_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_019_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_019_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_019_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_019_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_019_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_019_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_019_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_006(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_006_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_006_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchTemplateApplication, 4, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)3);
+    check_uint32_parameter("IVRApplications_006_LaunchTemplateApplication", 4);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchApplicationFromMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_CancelApplicationLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_CancelApplicationLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_006_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_006_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_SetDefaultApplicationForMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationLaunchArguments, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationLaunchArguments(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_006_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_006_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetTransitionState();
+    check_ptr_parameter("IVRApplications_006_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_006_IsQuitUserPromptRequested", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchInternalProcess, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetCurrentSceneProcessId, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetCurrentSceneProcessId)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetCurrentSceneProcessId();
+    check_ptr_parameter("IVRApplications_006_GetCurrentSceneProcessId", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSettings_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_GetSettingsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSettings_002_GetSettingsErrorNameFromEnum)(EVRSettingsError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_GetSettingsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSettings_002_GetSettingsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSettings_002_GetSettingsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_Sync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSettings_002_Sync)(bool bForce, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_Sync(1, (void *)2);
+    check_ptr_parameter("IVRSettings_002_Sync", this_ptr_value);
+    check_bool_parameter("IVRSettings_002_Sync", 1);
+    check_ptr_parameter("IVRSettings_002_Sync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_SetBool, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_SetBool)(const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_SetBool((void *)1, (void *)2, 1, (void *)4);
+    check_ptr_parameter("IVRSettings_002_SetBool", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_SetBool", (void *)1);
+    check_ptr_parameter("IVRSettings_002_SetBool", (void *)2);
+    check_bool_parameter("IVRSettings_002_SetBool", 1);
+    check_ptr_parameter("IVRSettings_002_SetBool", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_SetInt32, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_SetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_SetInt32((void *)1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSettings_002_SetInt32", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)1);
+    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)2);
+    check_uint32_parameter("IVRSettings_002_SetInt32", 3);
+    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_SetFloat, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_SetFloat)(const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_SetFloat((void *)1, (void *)2, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSettings_002_SetFloat", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)1);
+    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)2);
+    check_float_parameter("IVRSettings_002_SetFloat", 3.0f);
+    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_SetString, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_SetString)(const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_SetString((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSettings_002_SetString", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_SetString", (void *)1);
+    check_ptr_parameter("IVRSettings_002_SetString", (void *)2);
+    check_ptr_parameter("IVRSettings_002_SetString", (void *)3);
+    check_ptr_parameter("IVRSettings_002_SetString", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_GetBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSettings_002_GetBool)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_GetBool((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSettings_002_GetBool", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_GetBool", (void *)1);
+    check_ptr_parameter("IVRSettings_002_GetBool", (void *)2);
+    check_ptr_parameter("IVRSettings_002_GetBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_GetInt32, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSettings_002_GetInt32)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_GetInt32((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSettings_002_GetInt32", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)1);
+    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)2);
+    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_GetFloat, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSettings_002_GetFloat)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_GetFloat((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSettings_002_GetFloat", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)1);
+    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)2);
+    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_GetString, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_GetString)(const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_GetString((void *)1, (void *)2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSettings_002_GetString", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_GetString", (void *)1);
+    check_ptr_parameter("IVRSettings_002_GetString", (void *)2);
+    check_ptr_parameter("IVRSettings_002_GetString", (void *)3);
+    check_uint32_parameter("IVRSettings_002_GetString", 4);
+    check_ptr_parameter("IVRSettings_002_GetString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_RemoveSection, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_RemoveSection)(const char * pchSection, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_RemoveSection((void *)1, (void *)2);
+    check_ptr_parameter("IVRSettings_002_RemoveSection", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_RemoveSection", (void *)1);
+    check_ptr_parameter("IVRSettings_002_RemoveSection", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSettings_002_RemoveKeyInSection, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_002_RemoveKeyInSection)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_002_RemoveKeyInSection((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", this_ptr_value);
+    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)1);
+    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)2);
+    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRChaperone_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_GetCalibrationState, 0, FALSE, FALSE);
+    ChaperoneCalibrationState (__stdcall *capi_IVRChaperone_003_GetCalibrationState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_GetCalibrationState();
+    check_ptr_parameter("IVRChaperone_003_GetCalibrationState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_GetPlayAreaSize, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_003_GetPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_GetPlayAreaSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", (void *)1);
+    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_GetPlayAreaRect, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_003_GetPlayAreaRect)(HmdQuad_t * rect) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_GetPlayAreaRect((void *)1);
+    check_ptr_parameter("IVRChaperone_003_GetPlayAreaRect", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_003_GetPlayAreaRect", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_ReloadInfo, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_003_ReloadInfo)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_ReloadInfo();
+    check_ptr_parameter("IVRChaperone_003_ReloadInfo", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_SetSceneColor, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_003_SetSceneColor)(HmdColor_t color) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_SetSceneColor(DEFAULT_COLOR);
+    check_ptr_parameter("IVRChaperone_003_SetSceneColor", this_ptr_value);
+    check_HmdColor_parameter("IVRChaperone_003_SetSceneColor", DEFAULT_COLOR);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_GetBoundsColor, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRChaperone_003_GetBoundsColor)(HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t * pOutputCameraColor) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_GetBoundsColor((void *)1, 2, 3.0f, (void *)4);
+    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", (void *)1);
+    check_uint32_parameter("IVRChaperone_003_GetBoundsColor", 2);
+    check_float_parameter("IVRChaperone_003_GetBoundsColor", 3.0f);
+    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_AreBoundsVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_003_AreBoundsVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_AreBoundsVisible();
+    check_ptr_parameter("IVRChaperone_003_AreBoundsVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_003_ForceBoundsVisible, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_003_ForceBoundsVisible)(bool bForce) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_003_ForceBoundsVisible(1);
+    check_ptr_parameter("IVRChaperone_003_ForceBoundsVisible", this_ptr_value);
+    check_bool_parameter("IVRChaperone_003_ForceBoundsVisible", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRChaperoneSetup_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_CommitWorkingCopy, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_CommitWorkingCopy)(EChaperoneConfigFile configFile) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_CommitWorkingCopy(1);
+    check_ptr_parameter("IVRChaperoneSetup_005_CommitWorkingCopy", this_ptr_value);
+    check_uint32_parameter("IVRChaperoneSetup_005_CommitWorkingCopy", 1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_RevertWorkingCopy, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_RevertWorkingCopy)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_RevertWorkingCopy();
+    check_ptr_parameter("IVRChaperoneSetup_005_RevertWorkingCopy", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingPlayAreaSize, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetWorkingPlayAreaSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingPlayAreaRect, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingPlayAreaRect)(HmdQuad_t * rect) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetWorkingPlayAreaRect((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaRect", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaRect", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingPlayAreaSize, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingPlayAreaSize)(float sizeX, float sizeZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingPlayAreaSize(1.0f, 2.0f);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", this_ptr_value);
+    check_float_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", 1.0f);
+    check_float_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ReloadFromDisk, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_ReloadFromDisk)(EChaperoneConfigFile configFile) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_ReloadFromDisk(1);
+    check_ptr_parameter("IVRChaperoneSetup_005_ReloadFromDisk", this_ptr_value);
+    check_uint32_parameter("IVRChaperoneSetup_005_ReloadFromDisk", 1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo)(uint8_t * pTagsBuffer, uint32_t unTagCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo)(uint8_t * pTagsBuffer, uint32_t * punTagCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ExportLiveToBuffer, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_ExportLiveToBuffer)(char * pBuffer, uint32_t * pnBufferLength) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_ExportLiveToBuffer((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ImportFromBufferToWorking, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_005_ImportFromBufferToWorking)(const char * pBuffer, uint32_t nImportFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_005_ImportFromBufferToWorking((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", 2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_022(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_022_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_022_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_022_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_022_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_022_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_022_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_Submit", 1);
+    check_ptr_parameter("IVRCompositor_022_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_022_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_022_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_022_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_022_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_022_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_022_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_022_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_022_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_022_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_022_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_022_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_022_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_022_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_022_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_022_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_022_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_022_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_022_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_022_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_022_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_022_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_022_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_022_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_022_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_022_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_022_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_022_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_022_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_022_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_022_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_022_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_022_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_022_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_022_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_022_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_022_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_022_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_022_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_022_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_022_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_022_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_022_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_022_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_022_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_022_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_022_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_022_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ReleaseMirrorTextureD3D11((void *)1);
+    check_ptr_parameter("IVRCompositor_022_ReleaseMirrorTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_ReleaseMirrorTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_022_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_022_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_022_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_022_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_022_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_UnlockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_022_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_022_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", 3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_SetExplicitTimingMode, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_022_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_SetExplicitTimingMode(1);
+    check_ptr_parameter("IVRCompositor_022_SetExplicitTimingMode", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_022_SetExplicitTimingMode", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_022_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_022_SubmitExplicitTimingData)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_022_SubmitExplicitTimingData();
+    check_ptr_parameter("IVRCompositor_022_SubmitExplicitTimingData", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRNotifications_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRNotifications_002_CreateNotification, 7, FALSE, FALSE);
+    EVRNotificationError (__stdcall *capi_IVRNotifications_002_CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRNotifications_002_CreateNotification(1, 2, 3, (void *)4, 5, (void *)6, (void *)7);
+    check_ptr_parameter("IVRNotifications_002_CreateNotification", this_ptr_value);
+    check_uint64_parameter("IVRNotifications_002_CreateNotification", 1);
+    check_uint64_parameter("IVRNotifications_002_CreateNotification", 2);
+    check_uint32_parameter("IVRNotifications_002_CreateNotification", 3);
+    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)4);
+    check_uint32_parameter("IVRNotifications_002_CreateNotification", 5);
+    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)6);
+    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)7);
+
+    init_thunk(t, this_ptr_value, IVRNotifications_002_RemoveNotification, 1, FALSE, FALSE);
+    EVRNotificationError (__stdcall *capi_IVRNotifications_002_RemoveNotification)(VRNotificationId notificationId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRNotifications_002_RemoveNotification(1);
+    check_ptr_parameter("IVRNotifications_002_RemoveNotification", this_ptr_value);
+    check_uint32_parameter("IVRNotifications_002_RemoveNotification", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_018(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_018_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_018_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_018_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_018_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_018_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_018_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_018_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayName", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_018_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_018_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_018_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_018_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_018_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_018_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_018_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_018_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_018_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_018_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_018_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayRenderModel, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)2);
+    check_uint32_parameter("IVROverlay_018_GetOverlayRenderModel", 3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRenderModel, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayRenderModel(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_018_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_018_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_018_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_018_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_018_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_018_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_018_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_018_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_018_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_018_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_018_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_018_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_018_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_018_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
+    check_ptr_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", (void *)3);
+    check_float_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_018_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_018_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_018_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_018_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_018_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_018_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_018_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_018_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_018_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_018_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_018_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_018_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_018_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_018_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_018_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_018_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_HideKeyboard();
+    check_ptr_parameter("IVROverlay_018_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_018_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_018_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_018_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_018_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_018_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_018_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_018_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_018_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_018_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_018_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_018_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_018_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_018_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_018_CloseMessageOverlay", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRRenderModels_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadRenderModel_Async, 2, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadRenderModel_Async)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_LoadRenderModel_Async((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeRenderModel, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_005_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_FreeRenderModel((void *)1);
+    check_ptr_parameter("IVRRenderModels_005_FreeRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_FreeRenderModel", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadTexture_Async, 2, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadTexture_Async)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_LoadTexture_Async(1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_LoadTexture_Async", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_005_LoadTexture_Async", 1);
+    check_ptr_parameter("IVRRenderModels_005_LoadTexture_Async", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeTexture, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_005_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_FreeTexture((void *)1);
+    check_ptr_parameter("IVRRenderModels_005_FreeTexture", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_FreeTexture", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadTextureD3D11_Async, 3, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_LoadTextureD3D11_Async(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", 1);
+    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadIntoTextureD3D11_Async, 2, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadIntoTextureD3D11_Async)(TextureID_t textureId, void * pDstTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_LoadIntoTextureD3D11_Async(1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", 1);
+    check_ptr_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_005_FreeTextureD3D11)(void * pD3D11Texture2D) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_FreeTextureD3D11((void *)1);
+    check_ptr_parameter("IVRRenderModels_005_FreeTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_FreeTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelName, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetRenderModelName(1, (void *)2, 3);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelName", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_005_GetRenderModelName", 1);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelName", (void *)2);
+    check_uint32_parameter("IVRRenderModels_005_GetRenderModelName", 3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetRenderModelCount();
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentCount, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentCount)(const char * pchRenderModelName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetComponentCount((void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentCount", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentCount", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetComponentName((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentName", (void *)1);
+    check_uint32_parameter("IVRRenderModels_005_GetComponentName", 2);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_005_GetComponentName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentButtonMask, 2, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRRenderModels_005_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetComponentButtonMask((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentRenderModelName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_005_GetComponentRenderModelName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentState, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_005_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)3);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)4);
+    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_RenderModelHasComponent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_005_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_RenderModelHasComponent((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelThumbnailURL, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelThumbnailURL)(const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetRenderModelThumbnailURL((void *)1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)2);
+    check_uint32_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", 3);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelOriginalPath, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelOriginalPath)(const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetRenderModelOriginalPath((void *)1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)1);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)2);
+    check_uint32_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", 3);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRRenderModels_005_GetRenderModelErrorNameFromEnum)(EVRRenderModelError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_005_GetRenderModelErrorNameFromEnum(1);
+    check_ptr_parameter("IVRRenderModels_005_GetRenderModelErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_005_GetRenderModelErrorNameFromEnum", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRExtendedDisplay_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetWindowBounds, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRExtendedDisplay_001_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRExtendedDisplay_001_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", this_ptr_value);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)1);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)2);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)3);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetEyeOutputViewport, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRExtendedDisplay_001_GetEyeOutputViewport)(EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRExtendedDisplay_001_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", this_ptr_value);
+    check_uint32_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", 1);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)2);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)3);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)4);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetDXGIOutputInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRExtendedDisplay_001_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRExtendedDisplay_001_GetDXGIOutputInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", (void *)1);
+    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRTrackedCamera_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRTrackedCamera_003_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetCameraErrorNameFromEnum(1);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_HasCamera, 2, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_HasCamera(1, (void *)2);
+    check_ptr_parameter("IVRTrackedCamera_003_HasCamera", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_HasCamera", 1);
+    check_ptr_parameter("IVRTrackedCamera_003_HasCamera", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraFrameSize, 5, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraFrameSize", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraFrameSize", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraIntrinsics, 4, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetCameraIntrinsics(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraProjection, 5, TRUE, TRUE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetCameraProjection(1, 2, 3.0f, 4.0f, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraProjection", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraProjection", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetCameraProjection", 2);
+    check_float_parameter("IVRTrackedCamera_003_GetCameraProjection", 3.0f);
+    check_float_parameter("IVRTrackedCamera_003_GetCameraProjection", 4.0f);
+    check_ptr_parameter("IVRTrackedCamera_003_GetCameraProjection", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_AcquireVideoStreamingService, 2, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_AcquireVideoStreamingService(1, (void *)2);
+    check_ptr_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", 1);
+    check_ptr_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_ReleaseVideoStreamingService, 1, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_ReleaseVideoStreamingService(1);
+    check_ptr_parameter("IVRTrackedCamera_003_ReleaseVideoStreamingService", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_003_ReleaseVideoStreamingService", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", (void *)3);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 4);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", (void *)5);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 6);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureSize, 5, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetVideoStreamTextureSize(1, 2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetVideoStreamTextureD3D11(1, 2, (void *)3, (void *)4, (void *)5, 6);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)5);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 6);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureGL, 5, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_GetVideoStreamTextureGL(1, 2, (void *)3, (void *)4, 5);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 2);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", (void *)4);
+    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(1, 2);
+    check_ptr_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", 1);
+    check_uint32_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", 2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRScreenshots_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_RequestScreenshot, 4, FALSE, FALSE);
+    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_RequestScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_RequestScreenshot((void *)1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", this_ptr_value);
+    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)1);
+    check_uint32_parameter("IVRScreenshots_001_RequestScreenshot", 2);
+    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)3);
+    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_HookScreenshot, 2, FALSE, FALSE);
+    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_HookScreenshot)(EVRScreenshotType * pSupportedTypes, int numTypes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_HookScreenshot((void *)1, 2);
+    check_ptr_parameter("IVRScreenshots_001_HookScreenshot", this_ptr_value);
+    check_ptr_parameter("IVRScreenshots_001_HookScreenshot", (void *)1);
+    check_uint32_parameter("IVRScreenshots_001_HookScreenshot", 2);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_GetScreenshotPropertyType, 2, FALSE, FALSE);
+    EVRScreenshotType (__stdcall *capi_IVRScreenshots_001_GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_GetScreenshotPropertyType(1, (void *)2);
+    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyType", this_ptr_value);
+    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyType", 1);
+    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_GetScreenshotPropertyFilename, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRScreenshots_001_GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_GetScreenshotPropertyFilename(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", this_ptr_value);
+    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 1);
+    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 2);
+    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", (void *)3);
+    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 4);
+    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_UpdateScreenshotProgress, 2, TRUE, FALSE);
+    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_UpdateScreenshotProgress(1, 2.0f);
+    check_ptr_parameter("IVRScreenshots_001_UpdateScreenshotProgress", this_ptr_value);
+    check_uint32_parameter("IVRScreenshots_001_UpdateScreenshotProgress", 1);
+    check_float_parameter("IVRScreenshots_001_UpdateScreenshotProgress", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_TakeStereoScreenshot, 3, FALSE, FALSE);
+    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_TakeStereoScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_TakeStereoScreenshot((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", this_ptr_value);
+    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)1);
+    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)2);
+    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRScreenshots_001_SubmitScreenshot, 4, FALSE, FALSE);
+    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename) = (void *)t;
+
+    clear_parameters();
+    capi_IVRScreenshots_001_SubmitScreenshot(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", this_ptr_value);
+    check_uint32_parameter("IVRScreenshots_001_SubmitScreenshot", 1);
+    check_uint32_parameter("IVRScreenshots_001_SubmitScreenshot", 2);
+    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", (void *)3);
+    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", (void *)4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRResources_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRResources_001_LoadSharedResource, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRResources_001_LoadSharedResource)(const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRResources_001_LoadSharedResource((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRResources_001_LoadSharedResource", this_ptr_value);
+    check_ptr_parameter("IVRResources_001_LoadSharedResource", (void *)1);
+    check_ptr_parameter("IVRResources_001_LoadSharedResource", (void *)2);
+    check_uint32_parameter("IVRResources_001_LoadSharedResource", 3);
+
+    init_thunk(t, this_ptr_value, IVRResources_001_GetResourceFullPath, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRResources_001_GetResourceFullPath)(const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRResources_001_GetResourceFullPath((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRResources_001_GetResourceFullPath", this_ptr_value);
+    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)1);
+    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)2);
+    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)3);
+    check_uint32_parameter("IVRResources_001_GetResourceFullPath", 4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRDriverManager_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRDriverManager_001_GetDriverCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRDriverManager_001_GetDriverCount();
+    check_ptr_parameter("IVRDriverManager_001_GetDriverCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverName, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRDriverManager_001_GetDriverName)(DriverId_t nDriver, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRDriverManager_001_GetDriverName(1, (void *)2, 3);
+    check_ptr_parameter("IVRDriverManager_001_GetDriverName", this_ptr_value);
+    check_uint32_parameter("IVRDriverManager_001_GetDriverName", 1);
+    check_ptr_parameter("IVRDriverManager_001_GetDriverName", (void *)2);
+    check_uint32_parameter("IVRDriverManager_001_GetDriverName", 3);
+
+    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverHandle, 1, FALSE, FALSE);
+    DriverHandle_t (__stdcall *capi_IVRDriverManager_001_GetDriverHandle)(const char * pchDriverName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRDriverManager_001_GetDriverHandle((void *)1);
+    check_ptr_parameter("IVRDriverManager_001_GetDriverHandle", this_ptr_value);
+    check_ptr_parameter("IVRDriverManager_001_GetDriverHandle", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRInput_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_SetActionManifestPath, 1, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_SetActionManifestPath((void *)1);
+    check_ptr_parameter("IVRInput_003_SetActionManifestPath", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_SetActionManifestPath", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetActionSetHandle, 2, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetActionSetHandle((void *)1, (void *)2);
+    check_ptr_parameter("IVRInput_003_GetActionSetHandle", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_GetActionSetHandle", (void *)1);
+    check_ptr_parameter("IVRInput_003_GetActionSetHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetActionHandle, 2, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetActionHandle((void *)1, (void *)2);
+    check_ptr_parameter("IVRInput_003_GetActionHandle", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_GetActionHandle", (void *)1);
+    check_ptr_parameter("IVRInput_003_GetActionHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetInputSourceHandle, 2, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetInputSourceHandle((void *)1, (void *)2);
+    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", (void *)1);
+    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_UpdateActionState, 3, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_UpdateActionState((void *)1, 2, 3);
+    check_ptr_parameter("IVRInput_003_UpdateActionState", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_UpdateActionState", (void *)1);
+    check_uint32_parameter("IVRInput_003_UpdateActionState", 2);
+    check_uint32_parameter("IVRInput_003_UpdateActionState", 3);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetDigitalActionData, 3, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetDigitalActionData(1, (void *)2, 3);
+    check_ptr_parameter("IVRInput_003_GetDigitalActionData", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetDigitalActionData", 1);
+    check_ptr_parameter("IVRInput_003_GetDigitalActionData", (void *)2);
+    check_uint32_parameter("IVRInput_003_GetDigitalActionData", 3);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetAnalogActionData, 3, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetAnalogActionData(1, (void *)2, 3);
+    check_ptr_parameter("IVRInput_003_GetAnalogActionData", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetAnalogActionData", 1);
+    check_ptr_parameter("IVRInput_003_GetAnalogActionData", (void *)2);
+    check_uint32_parameter("IVRInput_003_GetAnalogActionData", 3);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetPoseActionData, 5, TRUE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetPoseActionData)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetPoseActionData(1, 2, 3.0f, (void *)4, 5);
+    check_ptr_parameter("IVRInput_003_GetPoseActionData", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetPoseActionData", 1);
+    check_uint32_parameter("IVRInput_003_GetPoseActionData", 2);
+    check_float_parameter("IVRInput_003_GetPoseActionData", 3.0f);
+    check_ptr_parameter("IVRInput_003_GetPoseActionData", (void *)4);
+    check_uint32_parameter("IVRInput_003_GetPoseActionData", 5);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetSkeletalActionData, 7, TRUE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetSkeletalActionData)(VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetSkeletalActionData(1, 2, 3.0f, (void *)4, 5, (void *)6, 7);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetSkeletalActionData", 1);
+    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 2);
+    check_float_parameter("IVRInput_003_GetSkeletalActionData", 3.0f);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", (void *)4);
+    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 5);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", (void *)6);
+    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 7);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetSkeletalActionDataCompressed, 6, TRUE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetSkeletalActionDataCompressed)(VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetSkeletalActionDataCompressed(1, 2, 3.0f, (void *)4, 5, (void *)6);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 1);
+    check_uint32_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 2);
+    check_float_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 3.0f);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", (void *)4);
+    check_uint32_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 5);
+    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_UncompressSkeletalActionData, 5, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_UncompressSkeletalActionData)(void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_UncompressSkeletalActionData((void *)1, 2, (void *)3, (void *)4, 5);
+    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)1);
+    check_uint32_parameter("IVRInput_003_UncompressSkeletalActionData", 2);
+    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)3);
+    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)4);
+    check_uint32_parameter("IVRInput_003_UncompressSkeletalActionData", 5);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_TriggerHapticVibrationAction, 5, TRUE, TRUE);
+    EVRInputError (__stdcall *capi_IVRInput_003_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f);
+    check_ptr_parameter("IVRInput_003_TriggerHapticVibrationAction", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_TriggerHapticVibrationAction", 1);
+    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 2.0f);
+    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 3.0f);
+    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 4.0f);
+    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 5.0f);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetActionOrigins, 4, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetActionOrigins(1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRInput_003_GetActionOrigins", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetActionOrigins", 1);
+    check_uint64_parameter("IVRInput_003_GetActionOrigins", 2);
+    check_ptr_parameter("IVRInput_003_GetActionOrigins", (void *)3);
+    check_uint32_parameter("IVRInput_003_GetActionOrigins", 4);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetOriginLocalizedName, 3, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetOriginLocalizedName(1, (void *)2, 3);
+    check_ptr_parameter("IVRInput_003_GetOriginLocalizedName", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetOriginLocalizedName", 1);
+    check_ptr_parameter("IVRInput_003_GetOriginLocalizedName", (void *)2);
+    check_uint32_parameter("IVRInput_003_GetOriginLocalizedName", 3);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
+    check_ptr_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", 1);
+    check_ptr_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", (void *)2);
+    check_uint32_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", 3);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_ShowActionOrigins, 2, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_ShowActionOrigins(1, 2);
+    check_ptr_parameter("IVRInput_003_ShowActionOrigins", this_ptr_value);
+    check_uint64_parameter("IVRInput_003_ShowActionOrigins", 1);
+    check_uint64_parameter("IVRInput_003_ShowActionOrigins", 2);
+
+    init_thunk(t, this_ptr_value, IVRInput_003_ShowBindingsForActionSet, 4, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_003_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_003_ShowBindingsForActionSet((void *)1, 2, 3, 4);
+    check_ptr_parameter("IVRInput_003_ShowBindingsForActionSet", this_ptr_value);
+    check_ptr_parameter("IVRInput_003_ShowBindingsForActionSet", (void *)1);
+    check_uint32_parameter("IVRInput_003_ShowBindingsForActionSet", 2);
+    check_uint32_parameter("IVRInput_003_ShowBindingsForActionSet", 3);
+    check_uint64_parameter("IVRInput_003_ShowBindingsForActionSet", 4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRIOBuffer_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Open, 5, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Open((void *)1, 2, 3, 4, (void *)5);
+    check_ptr_parameter("IVRIOBuffer_001_Open", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)1);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 2);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 3);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 4);
+    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Close, 1, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Close(1);
+    check_ptr_parameter("IVRIOBuffer_001_Close", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Close", 1);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Read, 4, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Read(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRIOBuffer_001_Read", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Read", 1);
+    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)2);
+    check_uint32_parameter("IVRIOBuffer_001_Read", 3);
+    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Write, 3, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Write(1, (void *)2, 3);
+    check_ptr_parameter("IVRIOBuffer_001_Write", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Write", 1);
+    check_ptr_parameter("IVRIOBuffer_001_Write", (void *)2);
+    check_uint32_parameter("IVRIOBuffer_001_Write", 3);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_PropertyContainer, 1, FALSE, FALSE);
+    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_001_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_PropertyContainer(1);
+    check_ptr_parameter("IVRIOBuffer_001_PropertyContainer", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_PropertyContainer", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRClientCore_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_Init, 2, FALSE, FALSE);
+    EVRInitError (__stdcall *capi_IVRClientCore_003_Init)(EVRApplicationType eApplicationType, const char * pStartupInfo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_Init(1, (void *)2);
+    check_ptr_parameter("IVRClientCore_003_Init", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_003_Init", 1);
+    check_ptr_parameter("IVRClientCore_003_Init", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_Cleanup, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRClientCore_003_Cleanup)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_Cleanup();
+    check_ptr_parameter("IVRClientCore_003_Cleanup", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_IsInterfaceVersionValid, 1, FALSE, FALSE);
+    EVRInitError (__stdcall *capi_IVRClientCore_003_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_IsInterfaceVersionValid((void *)1);
+    check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", this_ptr_value);
+    check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_GetGenericInterface, 2, FALSE, FALSE);
+    void * (__stdcall *capi_IVRClientCore_003_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_GetGenericInterface((void *)1, (void *)2);
+    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", this_ptr_value);
+    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)1);
+    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_BIsHmdPresent, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRClientCore_003_BIsHmdPresent)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_BIsHmdPresent();
+    check_ptr_parameter("IVRClientCore_003_BIsHmdPresent", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_GetEnglishStringForHmdError, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRClientCore_003_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_GetEnglishStringForHmdError(1);
+    check_ptr_parameter("IVRClientCore_003_GetEnglishStringForHmdError", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_003_GetEnglishStringForHmdError", 1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_003_GetIDForVRInitError, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRClientCore_003_GetIDForVRInitError)(EVRInitError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_003_GetIDForVRInitError(1);
+    check_ptr_parameter("IVRClientCore_003_GetIDForVRInitError", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_003_GetIDForVRInitError", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_017(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_017_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_017_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_017_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_017_GetProjectionMatrix", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_017_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_017_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_017_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_017_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_017_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_017_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_017_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_017_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetOutputDevice, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetOutputDevice((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetOutputDevice", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetOutputDevice", (void *)1);
+    check_uint32_parameter("IVRSystem_017_GetOutputDevice", 2);
+    check_ptr_parameter("IVRSystem_017_GetOutputDevice", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_017_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_017_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_017_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_017_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_017_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_017_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_017_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_017_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_017_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_017_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_017_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_017_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_017_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_017_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_017_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_017_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_017_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_017_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_017_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_017_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_017_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_017_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_017_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_017_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_017_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_017_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_017_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_017_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_017_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_017_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_017_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_017_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_017_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_017_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_017_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_017_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_017_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_017_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_017_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_017_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_017_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_017_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_017_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_017_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_017_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_017_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_017_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_017(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_017_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_017_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_017_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_017_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_017_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_017_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_017_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayName", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_017_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_017_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_017_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_017_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_017_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_017_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_017_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_017_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_017_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_017_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_017_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayRenderModel, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)2);
+    check_uint32_parameter("IVROverlay_017_GetOverlayRenderModel", 3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRenderModel, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayRenderModel(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_017_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_017_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_017_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_017_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_017_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_017_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_017_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_017_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_017_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_017_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_017_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_017_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_017_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_017_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
+    check_ptr_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", (void *)3);
+    check_float_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_017_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_017_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_017_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_017_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_017_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_017_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_017_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_017_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_017_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_017_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_017_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_017_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_017_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_017_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_017_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_017_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_HideKeyboard();
+    check_ptr_parameter("IVROverlay_017_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_017_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_017_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_017_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_017_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_017_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_017_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_017_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_017_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_017_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_017_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_017_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_017_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_017_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_017_CloseMessageOverlay", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_021(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_021_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_021_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_021_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_021_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_021_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_021_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_Submit", 1);
+    check_ptr_parameter("IVRCompositor_021_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_021_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_021_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_021_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_021_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_021_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_021_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_021_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_021_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_021_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_021_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_021_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_021_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_021_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_021_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_021_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_021_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_021_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_021_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_021_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_021_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_021_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_021_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_021_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_021_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_021_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_021_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_021_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_021_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_021_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_021_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_021_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_021_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_021_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_021_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_021_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_021_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_021_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_021_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_021_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_021_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_021_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_021_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_021_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_021_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_021_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_021_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_021_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ReleaseMirrorTextureD3D11((void *)1);
+    check_ptr_parameter("IVRCompositor_021_ReleaseMirrorTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_ReleaseMirrorTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_021_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_021_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_021_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_021_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_021_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_021_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_UnlockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_021_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_021_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", 3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_SetExplicitTimingMode, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_021_SetExplicitTimingMode)(bool bExplicitTimingMode) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_SetExplicitTimingMode(1);
+    check_ptr_parameter("IVRCompositor_021_SetExplicitTimingMode", this_ptr_value);
+    check_bool_parameter("IVRCompositor_021_SetExplicitTimingMode", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_021_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_021_SubmitExplicitTimingData)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_021_SubmitExplicitTimingData();
+    check_ptr_parameter("IVRCompositor_021_SubmitExplicitTimingData", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_016(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_016_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_016_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_016_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_016_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_016_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_016_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_016_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayName", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_016_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_016_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_016_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_016_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_016_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_016_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_016_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_016_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_016_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_016_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_016_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_016_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_016_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_016_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayRenderModel, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)2);
+    check_uint32_parameter("IVROverlay_016_GetOverlayRenderModel", 3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRenderModel, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayRenderModel(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_016_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_016_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_016_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_016_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_016_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_016_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_016_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_016_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_016_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_016_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_016_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_016_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_016_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_016_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_016_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_016_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_016_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_016_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_016_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_016_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_016_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_016_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_016_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_016_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_016_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_016_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_016_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_016_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_016_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_016_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_016_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_HideKeyboard();
+    check_ptr_parameter("IVROverlay_016_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_016_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_016_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_016_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_016_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_016_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_016_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_016_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_016_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_016_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_016_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_016_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_016_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_016_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_016_CloseMessageOverlay", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_016(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_016_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_016_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_016_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_016_GetProjectionMatrix", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_016_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_016_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_016_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_016_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_016_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_016_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_016_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_016_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetOutputDevice, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetOutputDevice((void *)1, 2);
+    check_ptr_parameter("IVRSystem_016_GetOutputDevice", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetOutputDevice", (void *)1);
+    check_uint32_parameter("IVRSystem_016_GetOutputDevice", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_016_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_016_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_016_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_016_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_016_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_016_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_016_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_016_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_016_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_016_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_016_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_016_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_016_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_016_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_016_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_016_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_016_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_016_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_016_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_016_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_016_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_016_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_016_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_016_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_016_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_016_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_016_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_016_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_016_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_016_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_016_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_016_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_016_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_016_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_016_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_016_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_016_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_016_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_016_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_016_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_016_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_016_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_016_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_016_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_016_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_016_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_016_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_020(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_020_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_020_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_020_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_020_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_020_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_020_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_Submit", 1);
+    check_ptr_parameter("IVRCompositor_020_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_020_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_020_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_020_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_020_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_020_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_020_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_020_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_020_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_020_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_020_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_020_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_020_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_020_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_020_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_020_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_020_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_020_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_020_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_020_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_020_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_020_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_020_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_020_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_020_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_020_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_020_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_020_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_020_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_020_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_020_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_020_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_020_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_020_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_020_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_020_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_020_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_020_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_020_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_020_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_020_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_020_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_020_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_020_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_020_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_020_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_020_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_020_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ReleaseMirrorTextureD3D11((void *)1);
+    check_ptr_parameter("IVRCompositor_020_ReleaseMirrorTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_ReleaseMirrorTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_020_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_020_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_020_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_020_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_020_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_020_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_020_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_UnlockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_020_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_020_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_020_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_020_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", 3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRClientCore_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_Init, 1, FALSE, FALSE);
+    EVRInitError (__stdcall *capi_IVRClientCore_002_Init)(EVRApplicationType eApplicationType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_Init(1);
+    check_ptr_parameter("IVRClientCore_002_Init", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_002_Init", 1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_Cleanup, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRClientCore_002_Cleanup)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_Cleanup();
+    check_ptr_parameter("IVRClientCore_002_Cleanup", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_IsInterfaceVersionValid, 1, FALSE, FALSE);
+    EVRInitError (__stdcall *capi_IVRClientCore_002_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_IsInterfaceVersionValid((void *)1);
+    check_ptr_parameter("IVRClientCore_002_IsInterfaceVersionValid", this_ptr_value);
+    check_ptr_parameter("IVRClientCore_002_IsInterfaceVersionValid", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_GetGenericInterface, 2, FALSE, FALSE);
+    void * (__stdcall *capi_IVRClientCore_002_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_GetGenericInterface((void *)1, (void *)2);
+    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", this_ptr_value);
+    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", (void *)1);
+    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_BIsHmdPresent, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRClientCore_002_BIsHmdPresent)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_BIsHmdPresent();
+    check_ptr_parameter("IVRClientCore_002_BIsHmdPresent", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_GetEnglishStringForHmdError, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRClientCore_002_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_GetEnglishStringForHmdError(1);
+    check_ptr_parameter("IVRClientCore_002_GetEnglishStringForHmdError", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_002_GetEnglishStringForHmdError", 1);
+
+    init_thunk(t, this_ptr_value, IVRClientCore_002_GetIDForVRInitError, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRClientCore_002_GetIDForVRInitError)(EVRInitError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRClientCore_002_GetIDForVRInitError(1);
+    check_ptr_parameter("IVRClientCore_002_GetIDForVRInitError", this_ptr_value);
+    check_uint32_parameter("IVRClientCore_002_GetIDForVRInitError", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_015(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_015_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_015_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_015_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_015_GetProjectionMatrix", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_015_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_015_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_015_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_015_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_015_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_015_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_015_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_015_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_015_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_015_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_015_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_015_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_015_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_015_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_015_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_015_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_015_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_015_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_015_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_015_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_015_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_015_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_015_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_015_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_015_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_015_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_015_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_015_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_015_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_015_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_015_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_015_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_015_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_015_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_015_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_015_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_015_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_015_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_015_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_015_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_015_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_015_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_015_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_015_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_015_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_015_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_015_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_015_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_015_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_015_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_015_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_015_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_015_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_015_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_015_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_014(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_014_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_014_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_014_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_014_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_014_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_014_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_014_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_014_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_014_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_014_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_014_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_014_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_014_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_014_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_014_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_014_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_014_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_014_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_014_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_014_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_014_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_014_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_014_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_014_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_014_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_014_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_014_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_014_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_014_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_014_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_014_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_014_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_014_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_014_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_014_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_014_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_014_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_014_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_014_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_014_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_014_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_014_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_014_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_014_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_014_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_014_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_014_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_014_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_014_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_014_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_014_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_014_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_014_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_HideKeyboard();
+    check_ptr_parameter("IVROverlay_014_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_014_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_014_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_014_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_014_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_014_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_014_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_014_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_014_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_014_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_014_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_014_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_014_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)6);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_019(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_019_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_019_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_019_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_019_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_019_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_019_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_Submit", 1);
+    check_ptr_parameter("IVRCompositor_019_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_019_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_019_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_019_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_019_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_019_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_019_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_019_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_019_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_019_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_019_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_019_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_019_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_019_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_019_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_019_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_019_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_019_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_019_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_019_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_019_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_019_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_019_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_019_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_019_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_019_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_019_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_019_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_019_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_019_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_019_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_019_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_019_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_019_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_019_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_019_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_019_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_019_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_019_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_019_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_019_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_019_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_019_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_019_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_019_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_019_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_019_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_019_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_019_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_019_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_019_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_019_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_019_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_019_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_019_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_UnlockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_019_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_019_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_019_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_019_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", 3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_014(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_014_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_014_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_014_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_014_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_014_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_014_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_014_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_014_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_014_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_014_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_014_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_014_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_014_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_014_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_014_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_014_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_014_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_014_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_014_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_014_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_014_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_014_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_014_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_014_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_014_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_014_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_014_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_014_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_014_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_014_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_014_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_014_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_014_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_014_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_014_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_014_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_014_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_014_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_014_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_014_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_014_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_014_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_014_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_014_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_014_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_014_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_014_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_014_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_014_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_014_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_014_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_014_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_014_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_014_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_014_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_014_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_014_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_014_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_014_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_014_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_018(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_018_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_018_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_018_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_018_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_018_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_018_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_Submit", 1);
+    check_ptr_parameter("IVRCompositor_018_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_018_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_018_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_018_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_018_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_018_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_018_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_018_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_018_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_018_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_018_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_018_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_018_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_018_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_018_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_018_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_018_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_018_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_018_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_018_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_018_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_018_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_018_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_018_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_018_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_018_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_018_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_018_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_018_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_018_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_018_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_018_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_018_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_018_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_018_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_018_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_018_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_018_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_018_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_018_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_018_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_018_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_018_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_018_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_018_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_018_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_018_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_018_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_018_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_018_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_018_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_018_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_018_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_018_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_018_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_018_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_018_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_018_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_018_UnlockGLSharedTextureForAccess", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_013(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_013_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_013_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_013_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_013_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_013_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_013_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_013_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_013_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_013_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_013_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_013_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_013_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_013_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_013_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_013_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_013_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_013_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_013_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_013_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_013_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_013_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_013_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_013_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_013_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_013_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_013_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_013_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_013_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_013_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_013_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_013_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_013_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_013_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_013_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_013_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_013_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_013_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_013_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_013_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTexture, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_013_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_013_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_013_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_013_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_013_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_013_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_013_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_013_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_013_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_013_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_013_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_013_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_013_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_013_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_013_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_013_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_013_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_HideKeyboard();
+    check_ptr_parameter("IVROverlay_013_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_013_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_013_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_013_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_013_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_013_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_013_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_013_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_013_SetOverlayIntersectionMask", 4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_012(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_012_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_012_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_012_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_012_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_012_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_012_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_012_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_012_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_012_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_012_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_012_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_012_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_012_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_012_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_012_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_012_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_012_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_012_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_012_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_012_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_012_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_012_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_012_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_012_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_012_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_012_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_012_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_012_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_012_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_012_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_012_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_012_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_012_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_012_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_012_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_012_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_012_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_012_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_012_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_012_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_012_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_012_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_012_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_012_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_012_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_012_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_012_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_012_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_012_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_012_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_012_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_012_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_012_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_012_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_012_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_012_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_012_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_012_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_012_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_012_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_016(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_016_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_016_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_016_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_016_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_016_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_016_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_016_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_016_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_Submit", 1);
+    check_ptr_parameter("IVRCompositor_016_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_016_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_016_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_016_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_016_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_016_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_016_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_016_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_016_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_016_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_016_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_016_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_016_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_016_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_016_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_016_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_016_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_016_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_016_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_016_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_016_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_016_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_016_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_016_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_016_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_016_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_016_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_016_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_016_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_016_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_016_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_016_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_016_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_016_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_016_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_016_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_016_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_016_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_016_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_016_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_016_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_016_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_016_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_016_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_016_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_016_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_016_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_016_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_016_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_016_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_016_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_016_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_016_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_016_UnlockGLSharedTextureForAccess", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSettings_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_GetSettingsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSettings_001_GetSettingsErrorNameFromEnum)(EVRSettingsError eError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_GetSettingsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSettings_001_GetSettingsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSettings_001_GetSettingsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_Sync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSettings_001_Sync)(bool bForce, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_Sync(1, (void *)2);
+    check_ptr_parameter("IVRSettings_001_Sync", this_ptr_value);
+    check_bool_parameter("IVRSettings_001_Sync", 1);
+    check_ptr_parameter("IVRSettings_001_Sync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_GetBool, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSettings_001_GetBool)(const char * pchSection, const char * pchSettingsKey, bool bDefaultValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_GetBool((void *)1, (void *)2, 1, (void *)4);
+    check_ptr_parameter("IVRSettings_001_GetBool", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_GetBool", (void *)1);
+    check_ptr_parameter("IVRSettings_001_GetBool", (void *)2);
+    check_bool_parameter("IVRSettings_001_GetBool", 1);
+    check_ptr_parameter("IVRSettings_001_GetBool", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_SetBool, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_SetBool)(const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_SetBool((void *)1, (void *)2, 1, (void *)4);
+    check_ptr_parameter("IVRSettings_001_SetBool", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_SetBool", (void *)1);
+    check_ptr_parameter("IVRSettings_001_SetBool", (void *)2);
+    check_bool_parameter("IVRSettings_001_SetBool", 1);
+    check_ptr_parameter("IVRSettings_001_SetBool", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_GetInt32, 4, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSettings_001_GetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nDefaultValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_GetInt32((void *)1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSettings_001_GetInt32", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)1);
+    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)2);
+    check_uint32_parameter("IVRSettings_001_GetInt32", 3);
+    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_SetInt32, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_SetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_SetInt32((void *)1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSettings_001_SetInt32", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)1);
+    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)2);
+    check_uint32_parameter("IVRSettings_001_SetInt32", 3);
+    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_GetFloat, 4, TRUE, FALSE);
+    float (__stdcall *capi_IVRSettings_001_GetFloat)(const char * pchSection, const char * pchSettingsKey, float flDefaultValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_GetFloat((void *)1, (void *)2, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSettings_001_GetFloat", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)1);
+    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)2);
+    check_float_parameter("IVRSettings_001_GetFloat", 3.0f);
+    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_SetFloat, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_SetFloat)(const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_SetFloat((void *)1, (void *)2, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSettings_001_SetFloat", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)1);
+    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)2);
+    check_float_parameter("IVRSettings_001_SetFloat", 3.0f);
+    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_GetString, 6, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_GetString)(const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, const char * pchDefaultValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_GetString((void *)1, (void *)2, (void *)3, 4, (void *)5, (void *)6);
+    check_ptr_parameter("IVRSettings_001_GetString", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_GetString", (void *)1);
+    check_ptr_parameter("IVRSettings_001_GetString", (void *)2);
+    check_ptr_parameter("IVRSettings_001_GetString", (void *)3);
+    check_uint32_parameter("IVRSettings_001_GetString", 4);
+    check_ptr_parameter("IVRSettings_001_GetString", (void *)5);
+    check_ptr_parameter("IVRSettings_001_GetString", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_SetString, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_SetString)(const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_SetString((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSettings_001_SetString", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_SetString", (void *)1);
+    check_ptr_parameter("IVRSettings_001_SetString", (void *)2);
+    check_ptr_parameter("IVRSettings_001_SetString", (void *)3);
+    check_ptr_parameter("IVRSettings_001_SetString", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_RemoveSection, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_RemoveSection)(const char * pchSection, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_RemoveSection((void *)1, (void *)2);
+    check_ptr_parameter("IVRSettings_001_RemoveSection", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_RemoveSection", (void *)1);
+    check_ptr_parameter("IVRSettings_001_RemoveSection", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSettings_001_RemoveKeyInSection, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSettings_001_RemoveKeyInSection)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSettings_001_RemoveKeyInSection((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", this_ptr_value);
+    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)1);
+    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)2);
+    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_005_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_005_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_005_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_005_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_005_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_005_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_005_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchTemplateApplication, 4, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)1);
+    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)2);
+    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)3);
+    check_uint32_parameter("IVRApplications_005_LaunchTemplateApplication", 4);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_005_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_CancelApplicationLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_005_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_CancelApplicationLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_005_CancelApplicationLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_CancelApplicationLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_005_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_005_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_005_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_005_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_005_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_005_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_005_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_005_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_005_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_005_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_005_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_005_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_005_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetTransitionState();
+    check_ptr_parameter("IVRApplications_005_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_005_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_005_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_005_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_005_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_005_IsQuitUserPromptRequested", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchInternalProcess, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_005_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", this_ptr_value);
+    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)1);
+    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)2);
+    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_015(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_015_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_015_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_015_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_015_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_015_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_015_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_015_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_015_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_Submit", 1);
+    check_ptr_parameter("IVRCompositor_015_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_015_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_015_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_015_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_015_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_015_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_015_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_015_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_015_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_015_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_015_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_015_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_015_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_015_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_015_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_015_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_015_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_015_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_015_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_015_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_015_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_015_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_015_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_015_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_015_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_015_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_015_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_015_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_015_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_015_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_015_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_015_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_015_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_015_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_015_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_015_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_015_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_015_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_015_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_015_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_015_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_015_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_015_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_015_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_RequestScreenshot, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_RequestScreenshot)(EVRScreenshotType type, const char * pchDestinationFileName, const char * pchVRDestinationFileName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_RequestScreenshot(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_RequestScreenshot", 1);
+    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", (void *)2);
+    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCurrentScreenshotType, 0, FALSE, FALSE);
+    EVRScreenshotType (__stdcall *capi_IVRCompositor_015_GetCurrentScreenshotType)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetCurrentScreenshotType();
+    check_ptr_parameter("IVRCompositor_015_GetCurrentScreenshotType", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_015_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_015_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_015_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_015_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_015_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_015_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_015_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_015_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_015_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_015_UnlockGLSharedTextureForAccess", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_012(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_012_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_012_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_012_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_012_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_012_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_012_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_012_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_012_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_012_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_012_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_012_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_012_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_012_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_012_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_012_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_012_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_012_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_012_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_012_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_012_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_012_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_012_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_012_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_012_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_012_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_012_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_012_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_012_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_012_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_012_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_012_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_012_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_012_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_012_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_012_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_012_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_012_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_012_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_012_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTexture, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_012_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_012_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_012_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_012_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_012_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_012_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_012_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_012_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_012_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_012_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_012_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_012_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_012_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_012_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_012_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_012_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_012_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_HideKeyboard();
+    check_ptr_parameter("IVROverlay_012_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_012_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_012_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_012_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_012_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRTrackedCamera_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRTrackedCamera_002_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_GetCameraErrorNameFromEnum(1);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_HasCamera, 2, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_HasCamera(1, (void *)2);
+    check_ptr_parameter("IVRTrackedCamera_002_HasCamera", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_HasCamera", 1);
+    check_ptr_parameter("IVRTrackedCamera_002_HasCamera", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraFrameSize, 5, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraFrameSize", 1);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraFrameSize", 2);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraIntrinisics, 4, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraIntrinisics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_GetCameraIntrinisics(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", 1);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", 2);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraProjection, 5, TRUE, TRUE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_GetCameraProjection(1, 2, 3.0f, 4.0f, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraProjection", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraProjection", 1);
+    check_uint32_parameter("IVRTrackedCamera_002_GetCameraProjection", 2);
+    check_float_parameter("IVRTrackedCamera_002_GetCameraProjection", 3.0f);
+    check_float_parameter("IVRTrackedCamera_002_GetCameraProjection", 4.0f);
+    check_ptr_parameter("IVRTrackedCamera_002_GetCameraProjection", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_AcquireVideoStreamingService, 2, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_AcquireVideoStreamingService(1, (void *)2);
+    check_ptr_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", 1);
+    check_ptr_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_ReleaseVideoStreamingService, 1, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_ReleaseVideoStreamingService(1);
+    check_ptr_parameter("IVRTrackedCamera_002_ReleaseVideoStreamingService", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_002_ReleaseVideoStreamingService", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
+    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_002_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
+    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", this_ptr_value);
+    check_uint64_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 1);
+    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 2);
+    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", (void *)3);
+    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 4);
+    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", (void *)5);
+    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 6);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_014(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_014_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_014_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_014_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_014_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_014_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_014_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_014_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_014_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_014_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_014_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_014_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_014_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_014_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_014_Submit", 1);
+    check_ptr_parameter("IVRCompositor_014_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_014_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_014_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_014_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_014_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_014_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_014_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_014_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_014_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_014_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_014_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_014_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_014_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_014_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_014_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_014_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_014_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_014_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_014_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_014_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_014_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_014_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_014_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_014_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_014_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_014_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_014_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_014_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_014_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_014_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_014_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_014_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_014_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_014_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_014_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_014_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_014_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_014_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_014_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_014_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_014_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_014_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_014_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_014_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_014_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_014_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_014_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_014_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_014_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_014_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_014_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_014_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_014_SuspendRendering", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_011(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_011_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_011_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_011_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_011_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_011_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_011_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_011_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_011_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_011_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_011_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_011_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_011_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_011_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_011_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_011_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_011_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_011_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_011_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_011_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_011_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_011_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_011_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_011_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_011_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_011_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_011_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_011_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_011_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_011_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_011_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_011_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_011_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_011_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_011_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_011_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_011_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_011_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_011_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_011_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTexture, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_011_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_011_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_011_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_011_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_011_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_011_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_011_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_011_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_011_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_011_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_011_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_011_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_011_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_011_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_011_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_011_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_011_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_HideKeyboard();
+    check_ptr_parameter("IVROverlay_011_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_011_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_011_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_011_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_011_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_013(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_013_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_013_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_013_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_013_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_013_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_013_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_013_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_013_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_013_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_013_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_013_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_013_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_013_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_013_Submit", 1);
+    check_ptr_parameter("IVRCompositor_013_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_013_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_013_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_013_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_013_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_013_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_013_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_013_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_013_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_013_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_013_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_013_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_013_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_013_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_013_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_013_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_013_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_013_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_013_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_013_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_013_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_013_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_013_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_013_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_013_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_013_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_013_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_013_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_013_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_013_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_013_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_013_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_013_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_013_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_013_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_013_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_013_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_013_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_013_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_013_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_013_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_013_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_013_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_013_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_013_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_013_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_013_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_013_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_013_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_013_ForceInterleavedReprojectionOn", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_011(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_011_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_011_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_011_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_011_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_011_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_011_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_011_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_011_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_011_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_011_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_011_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_011_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_011_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_011_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_011_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_011_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_011_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_011_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_011_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_011_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_011_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_011_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_011_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_011_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_011_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_011_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_011_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_011_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_011_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_011_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_011_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_011_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_011_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_011_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_011_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_011_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_011_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_011_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_011_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_011_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_011_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_011_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_011_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_011_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_011_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_011_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_011_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_011_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_011_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_011_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_011_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_011_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_011_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_011_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_011_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_011_AcknowledgeQuit_UserPrompt", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_PerformanceTestEnableCapture, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_PerformanceTestEnableCapture)(bool bEnable) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_PerformanceTestEnableCapture(1);
+    check_ptr_parameter("IVRSystem_011_PerformanceTestEnableCapture", this_ptr_value);
+    check_bool_parameter("IVRSystem_011_PerformanceTestEnableCapture", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_011_PerformanceTestReportFidelityLevelChange, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_011_PerformanceTestReportFidelityLevelChange)(int nFidelityLevel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_011_PerformanceTestReportFidelityLevelChange(1);
+    check_ptr_parameter("IVRSystem_011_PerformanceTestReportFidelityLevelChange", this_ptr_value);
+    check_uint32_parameter("IVRSystem_011_PerformanceTestReportFidelityLevelChange", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_004(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_004_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_004_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_004_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_004_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_004_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_004_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_004_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_004_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_CancelApplicationLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_004_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_CancelApplicationLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_004_CancelApplicationLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_CancelApplicationLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_004_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_004_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_004_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_004_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_004_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_004_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_004_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_004_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_004_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_004_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_004_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_004_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_004_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetTransitionState();
+    check_ptr_parameter("IVRApplications_004_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_004_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_004_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_004_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_004_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_004_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_004_IsQuitUserPromptRequested", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchInternalProcess, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_004_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", this_ptr_value);
+    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)1);
+    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)2);
+    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_010(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_010_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_010_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_010_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_010_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_010_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_010_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_010_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_010_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_010_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_010_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_010_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_010_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_010_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_010_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_010_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_010_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_010_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_010_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_010_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_010_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_010_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_010_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_010_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_010_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_010_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_010_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_010_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_010_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_010_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_010_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_010_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_010_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_010_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_010_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_010_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_010_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_010_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_010_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_010_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_010_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_010_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_010_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_010_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_010_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_010_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_010_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_010_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_010_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_010_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_010_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_010_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_010_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_010_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_010_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_010_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_010_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_010_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_010_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_010_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_010_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_010_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_010_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_HideKeyboard();
+    check_ptr_parameter("IVROverlay_010_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_010_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_010_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_010_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_010_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRRenderModels_004(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadRenderModel_Async, 2, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadRenderModel_Async)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_LoadRenderModel_Async((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", (void *)1);
+    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeRenderModel, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_004_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_FreeRenderModel((void *)1);
+    check_ptr_parameter("IVRRenderModels_004_FreeRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_FreeRenderModel", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadTexture_Async, 2, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadTexture_Async)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_LoadTexture_Async(1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_LoadTexture_Async", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_004_LoadTexture_Async", 1);
+    check_ptr_parameter("IVRRenderModels_004_LoadTexture_Async", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeTexture, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_004_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_FreeTexture((void *)1);
+    check_ptr_parameter("IVRRenderModels_004_FreeTexture", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_FreeTexture", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadTextureD3D11_Async, 3, FALSE, FALSE);
+    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_LoadTextureD3D11_Async(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", 1);
+    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_004_FreeTextureD3D11)(void * pD3D11Texture2D) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_FreeTextureD3D11((void *)1);
+    check_ptr_parameter("IVRRenderModels_004_FreeTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_FreeTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetRenderModelName, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_004_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetRenderModelName(1, (void *)2, 3);
+    check_ptr_parameter("IVRRenderModels_004_GetRenderModelName", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_004_GetRenderModelName", 1);
+    check_ptr_parameter("IVRRenderModels_004_GetRenderModelName", (void *)2);
+    check_uint32_parameter("IVRRenderModels_004_GetRenderModelName", 3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetRenderModelCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_004_GetRenderModelCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetRenderModelCount();
+    check_ptr_parameter("IVRRenderModels_004_GetRenderModelCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentCount, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentCount)(const char * pchRenderModelName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetComponentCount((void *)1);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentCount", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentCount", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetComponentName((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentName", (void *)1);
+    check_uint32_parameter("IVRRenderModels_004_GetComponentName", 2);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_004_GetComponentName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentButtonMask, 2, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRRenderModels_004_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetComponentButtonMask((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", (void *)1);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentRenderModelName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)1);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_004_GetComponentRenderModelName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentState, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_004_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)1);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)3);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)4);
+    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_004_RenderModelHasComponent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_004_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_004_RenderModelHasComponent((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", (void *)1);
+    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_012(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_012_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_012_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_012_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_012_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_012_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_012_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_012_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_012_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_012_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_012_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_012_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_012_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_012_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_012_Submit", 1);
+    check_ptr_parameter("IVRCompositor_012_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_012_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_012_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_012_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_012_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_012_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_012_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_012_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_012_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_012_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_012_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_012_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_012_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_012_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_012_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_012_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_012_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_012_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_012_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_012_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_012_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_012_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_012_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_012_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_012_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_012_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_012_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_012_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_012_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_012_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_012_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_012_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_012_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_012_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_012_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_012_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_012_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_012_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_012_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_012_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_012_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_012_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_012_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_012_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_012_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_012_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_012_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_012_ShouldAppRenderWithLowResources", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_003_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_003_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_003_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_003_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_003_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_003_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_003_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_003_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_003_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_003_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_003_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_003_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_003_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_003_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_003_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_003_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_003_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_003_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_003_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_003_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_003_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetTransitionState();
+    check_ptr_parameter("IVRApplications_003_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_003_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_003_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_003_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_003_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_003_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_003_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_003_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_003_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_003_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_003_IsQuitUserPromptRequested", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_011(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_011_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_011_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_011_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_011_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_011_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_011_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_011_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_011_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_011_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_011_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_011_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_011_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_011_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_011_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_011_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_011_Submit", 1);
+    check_ptr_parameter("IVRCompositor_011_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_011_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_011_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_011_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_011_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_011_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_011_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_011_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_011_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_011_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_011_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_011_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_011_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_011_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_011_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_011_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_011_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_011_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_011_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_011_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_011_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_011_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_011_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_011_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_011_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_011_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_011_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_011_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_011_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_011_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_011_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_011_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_011_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_011_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_011_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_011_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_011_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_011_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_011_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_011_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_011_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_011_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_011_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_011_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_011_CompositorDumpImages", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRRenderModels_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_LoadRenderModel, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_002_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_LoadRenderModel((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", (void *)1);
+    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_FreeRenderModel, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_002_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_FreeRenderModel((void *)1);
+    check_ptr_parameter("IVRRenderModels_002_FreeRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_FreeRenderModel", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_LoadTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_002_LoadTexture)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_LoadTexture(1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_LoadTexture", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_002_LoadTexture", 1);
+    check_ptr_parameter("IVRRenderModels_002_LoadTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_FreeTexture, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_002_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_FreeTexture((void *)1);
+    check_ptr_parameter("IVRRenderModels_002_FreeTexture", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_FreeTexture", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetRenderModelName, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_002_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetRenderModelName(1, (void *)2, 3);
+    check_ptr_parameter("IVRRenderModels_002_GetRenderModelName", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_002_GetRenderModelName", 1);
+    check_ptr_parameter("IVRRenderModels_002_GetRenderModelName", (void *)2);
+    check_uint32_parameter("IVRRenderModels_002_GetRenderModelName", 3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetRenderModelCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_002_GetRenderModelCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetRenderModelCount();
+    check_ptr_parameter("IVRRenderModels_002_GetRenderModelCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentCount, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentCount)(const char * pchRenderModelName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetComponentCount((void *)1);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentCount", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentCount", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetComponentName((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentName", (void *)1);
+    check_uint32_parameter("IVRRenderModels_002_GetComponentName", 2);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_002_GetComponentName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentButtonMask, 2, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRRenderModels_002_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetComponentButtonMask((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", (void *)1);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentRenderModelName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)1);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)3);
+    check_uint32_parameter("IVRRenderModels_002_GetComponentRenderModelName", 4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentState, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_002_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ComponentState_t * pComponentState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentState", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)1);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)3);
+    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_002_RenderModelHasComponent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_002_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_002_RenderModelHasComponent((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", (void *)1);
+    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_010(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_010_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_010_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_010_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_010_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_010_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_010_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_010_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_010_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_010_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_010_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_010_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_010_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_010_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_010_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_010_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_010_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_010_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_010_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_010_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_010_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_010_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_010_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_010_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_010_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_010_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_010_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_010_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_010_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_010_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_010_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_010_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_010_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_010_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_010_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_010_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_010_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_010_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_010_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_010_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_010_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_010_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_010_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_010_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_010_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_010_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_010_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_010_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_010_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_010_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_010_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_010_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_010_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_010_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_010_AcknowledgeQuit_UserPrompt", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_PerformanceTestEnableCapture, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_PerformanceTestEnableCapture)(bool bEnable) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_PerformanceTestEnableCapture(1);
+    check_ptr_parameter("IVRSystem_010_PerformanceTestEnableCapture", this_ptr_value);
+    check_bool_parameter("IVRSystem_010_PerformanceTestEnableCapture", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_010_PerformanceTestReportFidelityLevelChange, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_010_PerformanceTestReportFidelityLevelChange)(int nFidelityLevel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_010_PerformanceTestReportFidelityLevelChange(1);
+    check_ptr_parameter("IVRSystem_010_PerformanceTestReportFidelityLevelChange", this_ptr_value);
+    check_uint32_parameter("IVRSystem_010_PerformanceTestReportFidelityLevelChange", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_002_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_002_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_002_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_002_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_002_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_002_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_002_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_002_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_002_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_002_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_002_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_002_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_002_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_002_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_002_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_002_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_002_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_002_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_002_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_002_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetTransitionState();
+    check_ptr_parameter("IVRApplications_002_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_002_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_002_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_002_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_002_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_002_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_002_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_002_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_002_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_002_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_002_IsQuitUserPromptRequested", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRChaperoneSetup_004(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_CommitWorkingCopy, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_CommitWorkingCopy)(EChaperoneConfigFile configFile) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_CommitWorkingCopy(1);
+    check_ptr_parameter("IVRChaperoneSetup_004_CommitWorkingCopy", this_ptr_value);
+    check_uint32_parameter("IVRChaperoneSetup_004_CommitWorkingCopy", 1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_RevertWorkingCopy, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_RevertWorkingCopy)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_RevertWorkingCopy();
+    check_ptr_parameter("IVRChaperoneSetup_004_RevertWorkingCopy", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingPlayAreaSize, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetWorkingPlayAreaSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingPlayAreaRect, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingPlayAreaRect)(HmdQuad_t * rect) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetWorkingPlayAreaRect((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaRect", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaRect", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingPlayAreaSize, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingPlayAreaSize)(float sizeX, float sizeZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_SetWorkingPlayAreaSize(1.0f, 2.0f);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", this_ptr_value);
+    check_float_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", 1.0f);
+    check_float_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_ReloadFromDisk, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_ReloadFromDisk)(EChaperoneConfigFile configFile) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_ReloadFromDisk(1);
+    check_ptr_parameter("IVRChaperoneSetup_004_ReloadFromDisk", this_ptr_value);
+    check_uint32_parameter("IVRChaperoneSetup_004_ReloadFromDisk", 1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose((void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingWallTagInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingWallTagInfo)(uint8_t * pTagsBuffer, uint32_t unTagCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_SetWorkingWallTagInfo((void *)1, 2);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", (void *)1);
+    check_uint32_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveWallTagInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveWallTagInfo)(uint8_t * pTagsBuffer, uint32_t * punTagCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperoneSetup_004_GetLiveWallTagInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", (void *)1);
+    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_010(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_010_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_010_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_010_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_010_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_010_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_010_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_010_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_010_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_010_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_010_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_010_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_010_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_010_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_010_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_010_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_010_Submit", 1);
+    check_ptr_parameter("IVRCompositor_010_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_010_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_010_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_010_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_010_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_010_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_010_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_010_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_010_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_010_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_010_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_010_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_010_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_010_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_010_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_010_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_010_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_010_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_010_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_010_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_010_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_010_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_010_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_010_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_010_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_010_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_010_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_010_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_010_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_010_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_010_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_010_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_010_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_010_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_010_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_010_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_010_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_010_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_010_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_010_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_010_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_010_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_010_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_010_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_010_CompositorDumpImages", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_008(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_008_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_008_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_008_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_008_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_008_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_008_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_008_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_008_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_008_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_008_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_008_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_008_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_008_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_008_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_008_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_008_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_008_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_008_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_008_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_008_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_008_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_008_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_008_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_008_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_008_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_008_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_008_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_008_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_008_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_008_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_008_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_008_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_008_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_008_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_008_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_008_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_008_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_008_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_008_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_008_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_008_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_008_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_008_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_008_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_008_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_008_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_008_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_008_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_008_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_008_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_008_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_008_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_008_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_008_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_008_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_008_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_008_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_008_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_008_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_008_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_008_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_HideKeyboard();
+    check_ptr_parameter("IVROverlay_008_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_008_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_008_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_008_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_008_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRTrackedCamera_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_HasCamera, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_HasCamera)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_HasCamera(1);
+    check_ptr_parameter("IVRTrackedCamera_001_HasCamera", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_HasCamera", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraFirmwareDescription, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraFirmwareDescription)(TrackedDeviceIndex_t nDeviceIndex, char * pBuffer, uint32_t nBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetCameraFirmwareDescription(1, (void *)2, 3);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", 1);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", (void *)2);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", 3);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraFrameDimensions, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraFrameDimensions)(TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetCameraFrameDimensions(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", 1);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", 2);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", (void *)3);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_SetCameraVideoStreamFormat, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_SetCameraVideoStreamFormat)(TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_SetCameraVideoStreamFormat(1, 2);
+    check_ptr_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", 1);
+    check_uint32_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", 2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraVideoStreamFormat, 1, FALSE, FALSE);
+    ECameraVideoStreamFormat (__stdcall *capi_IVRTrackedCamera_001_GetCameraVideoStreamFormat)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetCameraVideoStreamFormat(1);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraVideoStreamFormat", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraVideoStreamFormat", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_EnableCameraForStreaming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_EnableCameraForStreaming)(TrackedDeviceIndex_t nDeviceIndex, bool bEnable) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_EnableCameraForStreaming(1, 1);
+    check_ptr_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", 1);
+    check_bool_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_StartVideoStream, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_StartVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_StartVideoStream(1);
+    check_ptr_parameter("IVRTrackedCamera_001_StartVideoStream", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_StartVideoStream", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_StopVideoStream, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_StopVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_StopVideoStream(1);
+    check_ptr_parameter("IVRTrackedCamera_001_StopVideoStream", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_StopVideoStream", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_IsVideoStreamActive, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_IsVideoStreamActive)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_IsVideoStreamActive(1);
+    check_ptr_parameter("IVRTrackedCamera_001_IsVideoStreamActive", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_IsVideoStreamActive", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetVideoStreamElapsedTime, 1, FALSE, FALSE);
+    float (__stdcall *capi_IVRTrackedCamera_001_GetVideoStreamElapsedTime)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetVideoStreamElapsedTime(1);
+    check_ptr_parameter("IVRTrackedCamera_001_GetVideoStreamElapsedTime", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetVideoStreamElapsedTime", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetVideoStreamFrame, 1, FALSE, FALSE);
+    const CameraVideoStreamFrame_t * (__stdcall *capi_IVRTrackedCamera_001_GetVideoStreamFrame)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetVideoStreamFrame(1);
+    check_ptr_parameter("IVRTrackedCamera_001_GetVideoStreamFrame", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetVideoStreamFrame", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_ReleaseVideoStreamFrame, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_ReleaseVideoStreamFrame)(TrackedDeviceIndex_t nDeviceIndex, CameraVideoStreamFrame_t * pFrameImage) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_ReleaseVideoStreamFrame(1, (void *)2);
+    check_ptr_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", 1);
+    check_ptr_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_SetAutoExposure, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_SetAutoExposure)(TrackedDeviceIndex_t nDeviceIndex, bool bEnable) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_SetAutoExposure(1, 1);
+    check_ptr_parameter("IVRTrackedCamera_001_SetAutoExposure", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_SetAutoExposure", 1);
+    check_bool_parameter("IVRTrackedCamera_001_SetAutoExposure", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_PauseVideoStream, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_PauseVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_PauseVideoStream(1);
+    check_ptr_parameter("IVRTrackedCamera_001_PauseVideoStream", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_PauseVideoStream", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_ResumeVideoStream, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_ResumeVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_ResumeVideoStream(1);
+    check_ptr_parameter("IVRTrackedCamera_001_ResumeVideoStream", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_ResumeVideoStream", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_IsVideoStreamPaused, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_IsVideoStreamPaused)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_IsVideoStreamPaused(1);
+    check_ptr_parameter("IVRTrackedCamera_001_IsVideoStreamPaused", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_IsVideoStreamPaused", 1);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraDistortion, 5, TRUE, FALSE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraDistortion)(TrackedDeviceIndex_t nDeviceIndex, float flInputU, float flInputV, float * pflOutputU, float * pflOutputV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetCameraDistortion(1, 2.0f, 3.0f, (void *)4, (void *)5);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraDistortion", 1);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraDistortion", 2.0f);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraDistortion", 3.0f);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", (void *)4);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraProjection, 6, TRUE, TRUE);
+    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, float flWidthPixels, float flHeightPixels, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;
+
+    clear_parameters();
+    capi_IVRTrackedCamera_001_GetCameraProjection(1, 2.0f, 3.0f, 4.0f, 5.0f, (void *)6);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraProjection", this_ptr_value);
+    check_uint32_parameter("IVRTrackedCamera_001_GetCameraProjection", 1);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 2.0f);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 3.0f);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 4.0f);
+    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 5.0f);
+    check_ptr_parameter("IVRTrackedCamera_001_GetCameraProjection", (void *)6);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_009(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_009_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_009_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_009_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_009_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_009_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_009_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_009_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_009_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_009_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_009_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_009_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_009_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_009_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_009_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_009_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_009_Submit", 1);
+    check_ptr_parameter("IVRCompositor_009_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_009_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_009_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_009_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_009_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_009_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_009_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_009_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_009_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_009_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_009_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_009_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_009_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_009_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_009_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_009_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_009_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_009_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_009_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_009_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_009_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_009_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_009_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_009_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_009_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_009_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_009_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_009_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_009_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_009_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_009_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_009_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_009_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_009_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_009_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_009_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_009_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_009_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_009_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_009_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_009_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_009_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_009_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_009_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_009_CompositorDumpImages", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_009(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_009_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_009_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_009_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_009_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_009_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_009_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_009_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_009_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_009_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_009_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_009_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_009_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_009_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_009_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_009_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_009_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_009_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_009_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_009_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_009_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_009_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_009_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_009_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_009_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_009_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_009_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_009_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_009_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_009_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_009_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_009_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_009_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_009_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_009_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_009_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_009_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_009_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_009_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_009_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_009_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_009_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_009_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_009_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_009_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_009_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_009_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_009_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_009_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_009_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_009_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_009_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_009_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_009_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_009_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_009_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_009_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_009_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_007(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_007_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_007_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_007_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetHighQualityOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_007_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_007_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_007_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_007_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_007_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_007_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_007_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_007_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_007_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_007_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_007_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_007_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_007_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_007_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_007_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_007_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_007_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_007_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_007_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_007_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_007_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_007_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_007_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_007_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_007_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_007_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_007_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_007_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_007_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_007_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_007_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_007_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_007_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_007_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_007_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_007_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_007_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_007_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_007_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_007_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_007_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_007_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_007_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_007_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_007_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_007_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_007_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_007_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_007_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_007_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_007_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_007_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_007_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_007_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_007_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_007_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_007_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_007_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_007_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_007_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_007_HideKeyboard();
+    check_ptr_parameter("IVROverlay_007_HideKeyboard", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_006(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetWindowBounds, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_006_GetWindowBounds", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)1);
+    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetEyeOutputViewport, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetEyeOutputViewport", 1);
+    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)4);
+    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_006_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_006_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_006_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_006_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_006_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_006_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_006_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_006_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_006_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_006_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_006_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_006_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_006_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetDXGIOutputInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetDXGIOutputInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", (void *)1);
+    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_AttachToWindow, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_AttachToWindow)(void * hWnd) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_AttachToWindow((void *)1);
+    check_ptr_parameter("IVRSystem_006_AttachToWindow", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_AttachToWindow", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_006_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass)(TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_006_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_006_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    TrackedDeviceClass (__stdcall *capi_IVRSystem_006_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_006_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_006_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_006_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_006_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_006_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_006_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_006_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_006_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_006_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_006_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_006_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_006_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_006_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_006_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_006_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_006_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_006_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_006_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_006_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_006_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_006_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_006_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_006_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_006_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_006_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_006_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_006_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_006_DriverDebugRequest", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    VRFirmwareError (__stdcall *capi_IVRSystem_006_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_006_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_006_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_006_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_006_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_006_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_006_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_006_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_006_SetDisplayVisibility", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_001_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_001_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_001_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_001_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_001_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_001_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_001_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_001_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_001_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_001_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_001_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_001_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_001_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_001_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetHomeApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetHomeApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetHomeApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_001_GetHomeApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetHomeApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_001_GetHomeApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_SetHomeApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_SetHomeApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_SetHomeApplication((void *)1);
+    check_ptr_parameter("IVRApplications_001_SetHomeApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_SetHomeApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_001_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_001_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_001_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_001_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_001_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_001_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetTransitionState();
+    check_ptr_parameter("IVRApplications_001_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_001_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_001_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_001_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_001_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_001_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_001_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_001_GetApplicationsTransitionStateNameFromEnum", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRChaperone_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_GetCalibrationState, 0, FALSE, FALSE);
+    ChaperoneCalibrationState (__stdcall *capi_IVRChaperone_002_GetCalibrationState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_GetCalibrationState();
+    check_ptr_parameter("IVRChaperone_002_GetCalibrationState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_GetSoftBoundsInfo, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_002_GetSoftBoundsInfo)(ChaperoneSoftBoundsInfo_t * pInfo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_GetSoftBoundsInfo((void *)1);
+    check_ptr_parameter("IVRChaperone_002_GetSoftBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_002_GetSoftBoundsInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_GetHardBoundsInfo, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_002_GetHardBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_GetHardBoundsInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", (void *)1);
+    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_GetSeatedBoundsInfo, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_002_GetSeatedBoundsInfo)(ChaperoneSeatedBoundsInfo_t * pInfo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_GetSeatedBoundsInfo((void *)1);
+    check_ptr_parameter("IVRChaperone_002_GetSeatedBoundsInfo", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_002_GetSeatedBoundsInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_ReloadInfo, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_002_ReloadInfo)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_ReloadInfo();
+    check_ptr_parameter("IVRChaperone_002_ReloadInfo", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_SetSceneColor, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_002_SetSceneColor)(HmdColor_t color) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_SetSceneColor(DEFAULT_COLOR);
+    check_ptr_parameter("IVRChaperone_002_SetSceneColor", this_ptr_value);
+    check_HmdColor_parameter("IVRChaperone_002_SetSceneColor", DEFAULT_COLOR);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_GetBoundsColor, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_002_GetBoundsColor)(HmdColor_t * pOutputColorArray, int nNumOutputColors) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_GetBoundsColor((void *)1, 2);
+    check_ptr_parameter("IVRChaperone_002_GetBoundsColor", this_ptr_value);
+    check_ptr_parameter("IVRChaperone_002_GetBoundsColor", (void *)1);
+    check_uint32_parameter("IVRChaperone_002_GetBoundsColor", 2);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_AreBoundsVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRChaperone_002_AreBoundsVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_AreBoundsVisible();
+    check_ptr_parameter("IVRChaperone_002_AreBoundsVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRChaperone_002_ForceBoundsVisible, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRChaperone_002_ForceBoundsVisible)(bool bForce) = (void *)t;
+
+    clear_parameters();
+    capi_IVRChaperone_002_ForceBoundsVisible(1);
+    check_ptr_parameter("IVRChaperone_002_ForceBoundsVisible", this_ptr_value);
+    check_bool_parameter("IVRChaperone_002_ForceBoundsVisible", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_008(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetLastError, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_008_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetLastError((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_008_GetLastError", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_008_GetLastError", (void *)1);
+    check_uint32_parameter("IVRCompositor_008_GetLastError", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_SetVSync, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_SetVSync)(bool bVSync) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_SetVSync(1);
+    check_ptr_parameter("IVRCompositor_008_SetVSync", this_ptr_value);
+    check_bool_parameter("IVRCompositor_008_SetVSync", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetVSync, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_008_GetVSync)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetVSync();
+    check_ptr_parameter("IVRCompositor_008_GetVSync", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_SetGamma, 1, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_SetGamma)(float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_SetGamma(1.0f);
+    check_ptr_parameter("IVRCompositor_008_SetGamma", this_ptr_value);
+    check_float_parameter("IVRCompositor_008_SetGamma", 1.0f);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetGamma, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_008_GetGamma)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetGamma();
+    check_ptr_parameter("IVRCompositor_008_GetGamma", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_WaitGetPoses, 4, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_008_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_008_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_008_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_Submit, 5, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_008_Submit)(Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds, VRSubmitFlags_t nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_Submit(1, 2, (void *)3, (void *)4, 5);
+    check_ptr_parameter("IVRCompositor_008_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_008_Submit", 1);
+    check_uint32_parameter("IVRCompositor_008_Submit", 2);
+    check_ptr_parameter("IVRCompositor_008_Submit", (void *)3);
+    check_ptr_parameter("IVRCompositor_008_Submit", (void *)4);
+    check_uint32_parameter("IVRCompositor_008_Submit", 5);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_008_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_008_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_008_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_008_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_008_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_008_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_008_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_008_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_008_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_008_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_008_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_008_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_008_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_008_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_008_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_008_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_SetSkyboxOverride, 7, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_SetSkyboxOverride)(GraphicsAPIConvention eTextureType, void * pFront, void * pBack, void * pLeft, void * pRight, void * pTop, void * pBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_SetSkyboxOverride(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_008_SetSkyboxOverride", 1);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)2);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)3);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)4);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)5);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)6);
+    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)7);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_008_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_008_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_008_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_008_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_008_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_008_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_008_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_008_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetTrackingSpace, 0, FALSE, FALSE);
+    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_008_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_008_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_008_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_008_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_008_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_008_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_008_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_008_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_008_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_008_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_008_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_008_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_008_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_008_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_008_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_008_GetLastFrameRenderer", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRNotifications_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRNotifications_001_GetErrorString, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRNotifications_001_GetErrorString)(NotificationError_t error, char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRNotifications_001_GetErrorString(1, (void *)2, 3);
+    check_ptr_parameter("IVRNotifications_001_GetErrorString", this_ptr_value);
+    check_uint32_parameter("IVRNotifications_001_GetErrorString", 1);
+    check_ptr_parameter("IVRNotifications_001_GetErrorString", (void *)2);
+    check_uint32_parameter("IVRNotifications_001_GetErrorString", 3);
+
+    init_thunk(t, this_ptr_value, IVRNotifications_001_CreateNotification, 7, FALSE, FALSE);
+    NotificationError_t (__stdcall *capi_IVRNotifications_001_CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, const char * strType, const char * strText, const char * strCategory, NotificationBitmap * photo, VRNotificationId * notificationId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRNotifications_001_CreateNotification(1, 2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", this_ptr_value);
+    check_uint64_parameter("IVRNotifications_001_CreateNotification", 1);
+    check_uint64_parameter("IVRNotifications_001_CreateNotification", 2);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)3);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)4);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)5);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)6);
+    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)7);
+
+    init_thunk(t, this_ptr_value, IVRNotifications_001_DismissNotification, 1, FALSE, FALSE);
+    NotificationError_t (__stdcall *capi_IVRNotifications_001_DismissNotification)(VRNotificationId notificationId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRNotifications_001_DismissNotification(1);
+    check_ptr_parameter("IVRNotifications_001_DismissNotification", this_ptr_value);
+    check_uint32_parameter("IVRNotifications_001_DismissNotification", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_FindOverlay, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_005_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_005_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_CreateOverlay, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_DestroyOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_005_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetHighQualityOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_005_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_005_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_005_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_005_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_005_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_005_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_005_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_005_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_005_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayImageData, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_005_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_005_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_005_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_005_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_005_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_005_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_005_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayColor, 4, TRUE, TRUE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_005_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_005_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_005_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_005_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayColor, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_005_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayAlpha, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_005_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_005_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayAlpha, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayGamma, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayGamma(1, 2.0f);
+    check_ptr_parameter("IVROverlay_005_SetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayGamma", 1);
+    check_float_parameter("IVROverlay_005_SetOverlayGamma", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayGamma, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayGamma(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayGamma", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayGamma", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_005_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_005_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformType, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_005_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_ShowOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_005_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_HideOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_005_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_005_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_005_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_005_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_005_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_005_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_IsFocusOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_IsFocusOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_IsFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_005_IsFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_IsFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTexture, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayTexture(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayTexture", 1);
+    check_uint32_parameter("IVROverlay_005_SetOverlayTexture", 2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayTexture", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_ClearOverlayTexture, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_005_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayRaw, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_005_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_005_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayFromFile, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_005_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_CreateDashboardOverlay, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_005_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_005_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_005_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_005_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_005_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_005_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_ShowKeyboard, 6, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_005_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1);
+    check_ptr_parameter("IVROverlay_005_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_005_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_005_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_005_ShowKeyboard", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_005_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_005_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_005_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_005_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_005_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_005_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_005_HideKeyboard();
+    check_ptr_parameter("IVROverlay_005_HideKeyboard", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRRenderModels_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_001_LoadRenderModel, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRRenderModels_001_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_001_LoadRenderModel((void *)1, (void *)2);
+    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", (void *)1);
+    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_001_FreeRenderModel, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRRenderModels_001_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_001_FreeRenderModel((void *)1);
+    check_ptr_parameter("IVRRenderModels_001_FreeRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRRenderModels_001_FreeRenderModel", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_001_GetRenderModelName, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_001_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_001_GetRenderModelName(1, (void *)2, 3);
+    check_ptr_parameter("IVRRenderModels_001_GetRenderModelName", this_ptr_value);
+    check_uint32_parameter("IVRRenderModels_001_GetRenderModelName", 1);
+    check_ptr_parameter("IVRRenderModels_001_GetRenderModelName", (void *)2);
+    check_uint32_parameter("IVRRenderModels_001_GetRenderModelName", 3);
+
+    init_thunk(t, this_ptr_value, IVRRenderModels_001_GetRenderModelCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRRenderModels_001_GetRenderModelCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRRenderModels_001_GetRenderModelCount();
+    check_ptr_parameter("IVRRenderModels_001_GetRenderModelCount", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetWindowBounds, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_005_GetWindowBounds", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)1);
+    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetEyeOutputViewport, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetEyeOutputViewport", 1);
+    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)4);
+    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_005_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_005_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_005_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_005_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_005_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_005_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_005_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_005_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_005_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_005_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_005_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_005_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_005_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetDXGIOutputInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetDXGIOutputInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", (void *)1);
+    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_AttachToWindow, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_AttachToWindow)(void * hWnd) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_AttachToWindow((void *)1);
+    check_ptr_parameter("IVRSystem_005_AttachToWindow", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_AttachToWindow", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_005_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass)(TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    TrackedDeviceClass (__stdcall *capi_IVRSystem_005_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_005_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_005_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_005_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_005_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_005_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_005_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_005_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_005_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_005_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_005_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_005_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_005_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_005_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_005_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_005_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_005_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_005_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_005_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_005_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_005_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_005_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_005_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_005_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_005_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_005_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_005_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_005_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_005_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_005_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_005_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_005_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_005_DriverDebugRequest", 4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_007(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetLastError, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_007_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetLastError((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_007_GetLastError", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_007_GetLastError", (void *)1);
+    check_uint32_parameter("IVRCompositor_007_GetLastError", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_SetVSync, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_SetVSync)(bool bVSync) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_SetVSync(1);
+    check_ptr_parameter("IVRCompositor_007_SetVSync", this_ptr_value);
+    check_bool_parameter("IVRCompositor_007_SetVSync", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetVSync, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_007_GetVSync)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetVSync();
+    check_ptr_parameter("IVRCompositor_007_GetVSync", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_SetGamma, 1, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_SetGamma)(float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_SetGamma(1.0f);
+    check_ptr_parameter("IVRCompositor_007_SetGamma", this_ptr_value);
+    check_float_parameter("IVRCompositor_007_SetGamma", 1.0f);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetGamma, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_007_GetGamma)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetGamma();
+    check_ptr_parameter("IVRCompositor_007_GetGamma", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_WaitGetPoses, 4, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_007_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_007_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_007_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_Submit, 4, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_007_Submit)(Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_Submit(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRCompositor_007_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_007_Submit", 1);
+    check_uint32_parameter("IVRCompositor_007_Submit", 2);
+    check_ptr_parameter("IVRCompositor_007_Submit", (void *)3);
+    check_ptr_parameter("IVRCompositor_007_Submit", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_007_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_007_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_007_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_007_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_007_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_007_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_007_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_007_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_007_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_007_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_007_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_007_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_007_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_007_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_007_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_007_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_007_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_007_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_007_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_007_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_007_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_007_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_007_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_007_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetTrackingSpace, 0, FALSE, FALSE);
+    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_007_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_007_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_007_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_007_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_007_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_007_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_007_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_007_CanRenderScene", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_004(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_FindOverlay, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_004_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_004_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_CreateOverlay, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_DestroyOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_004_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetHighQualityOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_004_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_004_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_004_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_004_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_004_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_004_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_004_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_004_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_004_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayImageData, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_004_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_004_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_004_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_004_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_004_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_004_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_004_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayColor, 4, TRUE, TRUE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_004_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_004_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_004_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_004_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayColor, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_004_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayAlpha, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_004_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_004_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayAlpha, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayGamma, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayGamma(1, 2.0f);
+    check_ptr_parameter("IVROverlay_004_SetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayGamma", 1);
+    check_float_parameter("IVROverlay_004_SetOverlayGamma", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayGamma, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayGamma(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayGamma", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayGamma", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_004_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_004_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformType, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_004_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_ShowOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_004_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_HideOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_004_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_004_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_004_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_004_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_004_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_004_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTexture, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayTexture(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayTexture", 1);
+    check_uint32_parameter("IVROverlay_004_SetOverlayTexture", 2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayTexture", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_ClearOverlayTexture, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_004_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayRaw, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_004_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_004_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayFromFile, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_004_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_CreateDashboardOverlay, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_004_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_004_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_004_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_004_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_004_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_004_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_004_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_004_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_004_ShowDashboard", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_FindOverlay, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_003_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_003_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_CreateOverlay, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_DestroyOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_003_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetHighQualityOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_003_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_003_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_003_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_003_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_003_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_003_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_003_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_003_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_003_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayImageData, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_003_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_003_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_003_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_003_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_003_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_003_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_003_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayColor, 4, TRUE, TRUE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_003_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_003_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_003_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_003_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayColor, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_003_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayAlpha, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_003_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_003_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayAlpha, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayGamma, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayGamma(1, 2.0f);
+    check_ptr_parameter("IVROverlay_003_SetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayGamma", 1);
+    check_float_parameter("IVROverlay_003_SetOverlayGamma", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayGamma, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayGamma(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayGamma", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayGamma", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_003_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_003_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformType, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_003_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_ShowOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_003_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_HideOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_003_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_003_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_003_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_003_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_003_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_003_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTexture, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayTexture(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayTexture", 1);
+    check_uint32_parameter("IVROverlay_003_SetOverlayTexture", 2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayTexture", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_ClearOverlayTexture, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_003_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayRaw, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_003_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_003_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayFromFile, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_003_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_CreateDashboardOverlay, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_003_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_003_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_003_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_003_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_003_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_003_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_003_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_003_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_003_ShowDashboard", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_002(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_FindOverlay, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_002_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_002_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_CreateOverlay, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_DestroyOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_002_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetHighQualityOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_002_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_002_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_002_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_002_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_002_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_002_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_002_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_002_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_002_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayColor, 4, TRUE, TRUE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_002_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_002_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_002_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_002_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayColor, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_002_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayAlpha, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_002_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_002_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayAlpha, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayGamma, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayGamma(1, 2.0f);
+    check_ptr_parameter("IVROverlay_002_SetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayGamma", 1);
+    check_float_parameter("IVROverlay_002_SetOverlayGamma", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayGamma, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayGamma(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayGamma", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayGamma", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_002_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_002_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformType, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_002_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_ShowOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_002_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_HideOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_002_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_002_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_002_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_002_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_002_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_002_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTexture, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayTexture(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayTexture", 1);
+    check_uint32_parameter("IVROverlay_002_SetOverlayTexture", 2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayTexture", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_ClearOverlayTexture, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_002_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayRaw, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_002_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_002_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayFromFile, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_002_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_CreateDashboardOverlay, 4, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_002_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_002_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_002_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_002_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_002_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_002_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_004(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetWindowBounds, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_004_GetWindowBounds", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)1);
+    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetEyeOutputViewport, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetEyeOutputViewport", 1);
+    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)4);
+    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_004_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_004_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_004_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_004_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_004_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_004_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_004_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_004_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_004_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_004_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_004_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_004_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_004_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetDXGIOutputInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetDXGIOutputInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", (void *)1);
+    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_AttachToWindow, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_AttachToWindow)(void * hWnd) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_AttachToWindow((void *)1);
+    check_ptr_parameter("IVRSystem_004_AttachToWindow", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_AttachToWindow", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_004_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    TrackedDeviceClass (__stdcall *capi_IVRSystem_004_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_004_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_004_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_004_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_004_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_004_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_004_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_004_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_004_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_004_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_004_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_004_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_004_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_004_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_004_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_004_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_004_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_004_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_004_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_004_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_004_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_004_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_004_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_004_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_004_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_004_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_004_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_004_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_004_DriverDebugRequest, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_004_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_004_DriverDebugRequest(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", this_ptr_value);
+    check_uint32_parameter("IVRSystem_004_DriverDebugRequest", 1);
+    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", (void *)2);
+    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", (void *)3);
+    check_uint32_parameter("IVRSystem_004_DriverDebugRequest", 4);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_006(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetLastError, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_006_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetLastError((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_006_GetLastError", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_006_GetLastError", (void *)1);
+    check_uint32_parameter("IVRCompositor_006_GetLastError", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_SetVSync, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_SetVSync)(bool bVSync) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_SetVSync(1);
+    check_ptr_parameter("IVRCompositor_006_SetVSync", this_ptr_value);
+    check_bool_parameter("IVRCompositor_006_SetVSync", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetVSync, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_006_GetVSync)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetVSync();
+    check_ptr_parameter("IVRCompositor_006_GetVSync", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_SetGamma, 1, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_SetGamma)(float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_SetGamma(1.0f);
+    check_ptr_parameter("IVRCompositor_006_SetGamma", this_ptr_value);
+    check_float_parameter("IVRCompositor_006_SetGamma", 1.0f);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetGamma, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_006_GetGamma)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetGamma();
+    check_ptr_parameter("IVRCompositor_006_GetGamma", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_SetGraphicsDevice, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_SetGraphicsDevice)(Compositor_DeviceType eType, void * pDevice) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_SetGraphicsDevice(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_006_SetGraphicsDevice", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_006_SetGraphicsDevice", 1);
+    check_ptr_parameter("IVRCompositor_006_SetGraphicsDevice", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_WaitGetPoses, 4, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_006_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_006_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_006_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_Submit, 3, FALSE, FALSE);
+    VRCompositorError (__stdcall *capi_IVRCompositor_006_Submit)(Hmd_Eye eEye, void * pTexture, VRTextureBounds_t * pBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_Submit(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_006_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_006_Submit", 1);
+    check_ptr_parameter("IVRCompositor_006_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_006_Submit", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_006_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_006_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_006_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_006_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_006_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_006_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_006_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_006_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_006_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_006_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_006_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_006_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_006_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_006_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_006_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_006_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_006_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_006_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_006_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_006_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_006_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_006_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_006_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_006_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetTrackingSpace, 0, FALSE, FALSE);
+    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_006_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_006_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_006_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_006_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_006_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_006_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_006_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_006_CanRenderScene", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_FindOverlay, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_001_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_001_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_CreateOverlay, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_DestroyOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_001_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetHighQualityOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetHighQualityOverlay(1);
+    check_ptr_parameter("IVROverlay_001_SetHighQualityOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetHighQualityOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetHighQualityOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_001_GetHighQualityOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetHighQualityOverlay();
+    check_ptr_parameter("IVROverlay_001_GetHighQualityOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_001_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_001_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_001_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_001_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayFlag, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_001_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayAlpha, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_001_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_001_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayAlpha, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayGamma, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayGamma(1, 2.0f);
+    check_ptr_parameter("IVROverlay_001_SetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayGamma", 1);
+    check_float_parameter("IVROverlay_001_SetOverlayGamma", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayGamma, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayGamma(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayGamma", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayGamma", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayGamma", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_001_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_001_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformType, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_001_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayVisibility, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayVisibility)(VROverlayHandle_t ulOverlayHandle, VROverlayVisibility * peOverlayVisibility) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayVisibility(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayVisibility", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayVisibility", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayVisibility", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayVisibility, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayVisibility)(VROverlayHandle_t ulOverlayHandle, VROverlayVisibility eOverlayVisibility) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayVisibility(1, 2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayVisibility", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayVisibility", 1);
+    check_uint32_parameter("IVROverlay_001_SetOverlayVisibility", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_ShowOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_001_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_HideOverlay, 1, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_001_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_001_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_PollNextOverlayEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_PollNextOverlayEvent(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_001_PollNextOverlayEvent", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayInputMethod, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_001_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_001_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayMouseScale, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_HandleControllerOverlayInteractionAsMouse(1, 2);
+    check_ptr_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", 1);
+    check_uint32_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTexture, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayRaw, 5, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_001_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayFromFile, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_001_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_IsSystemOverlayVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_IsSystemOverlayVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_IsSystemOverlayVisible();
+    check_ptr_parameter("IVROverlay_001_IsSystemOverlayVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_IsActiveSystemOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_001_IsActiveSystemOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_IsActiveSystemOverlay(1);
+    check_ptr_parameter("IVROverlay_001_IsActiveSystemOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_IsActiveSystemOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_SetSystemOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_SetSystemOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_SetSystemOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_001_GetSystemOverlaySceneProcess, 2, FALSE, FALSE);
+    VROverlayError (__stdcall *capi_IVROverlay_001_GetSystemOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_001_GetSystemOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", (void *)2);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRSystem_003(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetWindowBounds, 4, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_003_GetWindowBounds", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)1);
+    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetEyeOutputViewport, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetEyeOutputViewport", 1);
+    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)4);
+    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetProjectionMatrix, 5, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_003_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
+    check_ptr_parameter("IVRSystem_003_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_003_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_003_GetProjectionMatrix", 3.0f);
+    check_uint32_parameter("IVRSystem_003_GetProjectionMatrix", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_ComputeDistortion, 4, TRUE, TRUE);
+    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_003_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_003_ComputeDistortion", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_ComputeDistortion", data_ptr_value);
+    check_uint32_parameter("IVRSystem_003_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_003_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_003_ComputeDistortion", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_003_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_003_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_003_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetDXGIOutputInfo, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetDXGIOutputInfo((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", (void *)1);
+    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_AttachToWindow, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_AttachToWindow)(void * hWnd) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_AttachToWindow((void *)1);
+    check_ptr_parameter("IVRSystem_003_AttachToWindow", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_AttachToWindow", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_003_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_LoadRenderModel, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_LoadRenderModel((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_003_LoadRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_LoadRenderModel", (void *)1);
+    check_ptr_parameter("IVRSystem_003_LoadRenderModel", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_FreeRenderModel, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_FreeRenderModel((void *)1);
+    check_ptr_parameter("IVRSystem_003_FreeRenderModel", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_FreeRenderModel", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    TrackedDeviceClass (__stdcall *capi_IVRSystem_003_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_003_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_003_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_003_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_003_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_003_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_003_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_003_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_003_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_PollNextEvent, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_PollNextEvent)(VREvent_t * pEvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_PollNextEvent((void *)1);
+    check_ptr_parameter("IVRSystem_003_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_PollNextEvent", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_PollNextEventWithPose, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_PollNextEventWithPose(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", (void *)2);
+    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_003_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_003_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetHiddenAreaMesh, 2, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_003_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetHiddenAreaMesh(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_003_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetHiddenAreaMesh", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerState, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetControllerState(1, (void *)2);
+    check_ptr_parameter("IVRSystem_003_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_003_GetControllerState", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerStateWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_003_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", (void *)3);
+    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_003_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_003_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_003_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_003_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_003_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_003_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_HandleControllerOverlayInteractionAsMouse, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_HandleControllerOverlayInteractionAsMouse)(Compositor_OverlaySettings * overlaySettings, HmdVector2_t vecWindowClientPositionOnScreen, HmdVector2_t vecWindowClientSize, TrackedDeviceIndex_t unControllerDeviceIndex, EVRControllerEventOutputType eOutputType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_HandleControllerOverlayInteractionAsMouse((void *)1, DEFAULT_VECTOR2, DEFAULT_VECTOR2, 4, 5);
+    check_ptr_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
+    check_ptr_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", (void *)1);
+    check_HmdVector2_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", DEFAULT_VECTOR2);
+    check_HmdVector2_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", DEFAULT_VECTOR2);
+    check_uint32_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", 4);
+    check_uint32_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", 5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_CaptureInputFocus, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_CaptureInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_CaptureInputFocus();
+    check_ptr_parameter("IVRSystem_003_CaptureInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_ReleaseInputFocus, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_003_ReleaseInputFocus)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_ReleaseInputFocus();
+    check_ptr_parameter("IVRSystem_003_ReleaseInputFocus", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_003_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_003_IsInputFocusCapturedByAnotherProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_003_IsInputFocusCapturedByAnotherProcess();
+    check_ptr_parameter("IVRSystem_003_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRCompositor_005(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetLastError, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_005_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetLastError((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_005_GetLastError", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_GetLastError", (void *)1);
+    check_uint32_parameter("IVRCompositor_005_GetLastError", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetVSync, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetVSync)(bool bVSync) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetVSync(1);
+    check_ptr_parameter("IVRCompositor_005_SetVSync", this_ptr_value);
+    check_bool_parameter("IVRCompositor_005_SetVSync", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetVSync, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_005_GetVSync)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetVSync();
+    check_ptr_parameter("IVRCompositor_005_GetVSync", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetGamma, 1, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetGamma)(float fGamma) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetGamma(1.0f);
+    check_ptr_parameter("IVRCompositor_005_SetGamma", this_ptr_value);
+    check_float_parameter("IVRCompositor_005_SetGamma", 1.0f);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetGamma, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_005_GetGamma)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetGamma();
+    check_ptr_parameter("IVRCompositor_005_GetGamma", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetGraphicsDevice, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetGraphicsDevice)(Compositor_DeviceType eType, void * pDevice) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetGraphicsDevice(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_005_SetGraphicsDevice", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_005_SetGraphicsDevice", 1);
+    check_ptr_parameter("IVRCompositor_005_SetGraphicsDevice", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_WaitGetPoses, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_WaitGetPoses)(TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_WaitGetPoses((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_005_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_005_WaitGetPoses", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_Submit, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_Submit)(Hmd_Eye eEye, void * pTexture, Compositor_TextureBounds * pBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_Submit(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_005_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_005_Submit", 1);
+    check_ptr_parameter("IVRCompositor_005_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_005_Submit", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_005_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetOverlayDefaults, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_GetOverlayDefaults)(Compositor_OverlaySettings * pSettings) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetOverlayDefaults((void *)1);
+    check_ptr_parameter("IVRCompositor_005_GetOverlayDefaults", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_GetOverlayDefaults", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetOverlay)(void * pTexture, Compositor_OverlaySettings * pSettings) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVRCompositor_005_SetOverlay", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_SetOverlay", (void *)1);
+    check_ptr_parameter("IVRCompositor_005_SetOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlayRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetOverlayRaw)(void * buffer, uint32_t width, uint32_t height, uint32_t depth, Compositor_OverlaySettings * pSettings) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetOverlayRaw((void *)1, 2, 3, 4, (void *)5);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", (void *)1);
+    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 2);
+    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 3);
+    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 4);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlayFromFile, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetOverlayFromFile)(const char * pchFilePath, Compositor_OverlaySettings * pSettings) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetOverlayFromFile((void *)1, (void *)2);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", (void *)1);
+    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_ClearOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_ClearOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_ClearOverlay();
+    check_ptr_parameter("IVRCompositor_005_ClearOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_005_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_005_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_005_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_005_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_005_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_005_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_005_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_005_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_005_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_005_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_005_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_005_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_005_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_005_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_005_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_005_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_005_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_005_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_005_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_ComputeOverlayIntersection, 7, TRUE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_005_ComputeOverlayIntersection)(Compositor_OverlaySettings * pSettings, float fAspectRatio, TrackingUniverseOrigin eOrigin, HmdVector3_t vSource, HmdVector3_t vDirection, HmdVector2_t * pvecIntersectionUV, HmdVector3_t * pvecIntersectionTrackingSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_ComputeOverlayIntersection((void *)1, 2.0f, 3, DEFAULT_VECTOR3, DEFAULT_VECTOR3, (void *)6, (void *)7);
+    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)1);
+    check_float_parameter("IVRCompositor_005_ComputeOverlayIntersection", 2.0f);
+    check_uint32_parameter("IVRCompositor_005_ComputeOverlayIntersection", 3);
+    check_HmdVector3_parameter("IVRCompositor_005_ComputeOverlayIntersection", DEFAULT_VECTOR3);
+    check_HmdVector3_parameter("IVRCompositor_005_ComputeOverlayIntersection", DEFAULT_VECTOR3);
+    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)6);
+    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)7);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_005_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_005_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_005_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_005_GetTrackingSpace, 0, FALSE, FALSE);
+    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_005_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_005_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_005_GetTrackingSpace", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
diff --git a/vrclient_x64/tests/main_autogen.c b/vrclient_x64/tests/main_autogen.c
new file mode 100644
index 00000000..d5dd65e6
--- /dev/null
+++ b/vrclient_x64/tests/main_autogen.c
@@ -0,0 +1,83 @@
+/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+#include <stdio.h>
+
+int main(void)
+{
+    test_capi_thunks_IVRSystem_019();
+    test_capi_thunks_IVRApplications_006();
+    test_capi_thunks_IVRSettings_002();
+    test_capi_thunks_IVRChaperone_003();
+    test_capi_thunks_IVRChaperoneSetup_005();
+    test_capi_thunks_IVRCompositor_022();
+    test_capi_thunks_IVRNotifications_002();
+    test_capi_thunks_IVROverlay_018();
+    test_capi_thunks_IVRRenderModels_005();
+    test_capi_thunks_IVRExtendedDisplay_001();
+    test_capi_thunks_IVRTrackedCamera_003();
+    test_capi_thunks_IVRScreenshots_001();
+    test_capi_thunks_IVRResources_001();
+    test_capi_thunks_IVRDriverManager_001();
+    test_capi_thunks_IVRInput_003();
+    test_capi_thunks_IVRIOBuffer_001();
+    test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRSystem_017();
+    test_capi_thunks_IVROverlay_017();
+    test_capi_thunks_IVRCompositor_021();
+    test_capi_thunks_IVROverlay_016();
+    test_capi_thunks_IVRSystem_016();
+    test_capi_thunks_IVRCompositor_020();
+    test_capi_thunks_IVRClientCore_002();
+    test_capi_thunks_IVRSystem_015();
+    test_capi_thunks_IVROverlay_014();
+    test_capi_thunks_IVRCompositor_019();
+    test_capi_thunks_IVRSystem_014();
+    test_capi_thunks_IVRCompositor_018();
+    test_capi_thunks_IVROverlay_013();
+    test_capi_thunks_IVRSystem_012();
+    test_capi_thunks_IVRCompositor_016();
+    test_capi_thunks_IVRSettings_001();
+    test_capi_thunks_IVRApplications_005();
+    test_capi_thunks_IVRCompositor_015();
+    test_capi_thunks_IVROverlay_012();
+    test_capi_thunks_IVRTrackedCamera_002();
+    test_capi_thunks_IVRCompositor_014();
+    test_capi_thunks_IVROverlay_011();
+    test_capi_thunks_IVRCompositor_013();
+    test_capi_thunks_IVRSystem_011();
+    test_capi_thunks_IVRApplications_004();
+    test_capi_thunks_IVROverlay_010();
+    test_capi_thunks_IVRRenderModels_004();
+    test_capi_thunks_IVRCompositor_012();
+    test_capi_thunks_IVRApplications_003();
+    test_capi_thunks_IVRCompositor_011();
+    test_capi_thunks_IVRRenderModels_002();
+    test_capi_thunks_IVRSystem_010();
+    test_capi_thunks_IVRApplications_002();
+    test_capi_thunks_IVRChaperoneSetup_004();
+    test_capi_thunks_IVRCompositor_010();
+    test_capi_thunks_IVROverlay_008();
+    test_capi_thunks_IVRTrackedCamera_001();
+    test_capi_thunks_IVRCompositor_009();
+    test_capi_thunks_IVRSystem_009();
+    test_capi_thunks_IVROverlay_007();
+    test_capi_thunks_IVRSystem_006();
+    test_capi_thunks_IVRApplications_001();
+    test_capi_thunks_IVRChaperone_002();
+    test_capi_thunks_IVRCompositor_008();
+    test_capi_thunks_IVRNotifications_001();
+    test_capi_thunks_IVROverlay_005();
+    test_capi_thunks_IVRRenderModels_001();
+    test_capi_thunks_IVRSystem_005();
+    test_capi_thunks_IVRCompositor_007();
+    test_capi_thunks_IVROverlay_004();
+    test_capi_thunks_IVROverlay_003();
+    test_capi_thunks_IVROverlay_002();
+    test_capi_thunks_IVRSystem_004();
+    test_capi_thunks_IVRCompositor_006();
+    test_capi_thunks_IVROverlay_001();
+    test_capi_thunks_IVRSystem_003();
+    test_capi_thunks_IVRCompositor_005();
+    printf("All tests executed.\n");
+}