From f7510f2a7ba0d1aaad10fd820a345bbb33cc6c49 Mon Sep 17 00:00:00 2001 From: Zebediah Figura Date: Mon, 4 Jun 2018 10:45:00 -0500 Subject: [PATCH] vrclient: Add support for flat (FnTable) API --- vrclient_x64/cxx.h | 4 +- vrclient_x64/flatapi.h | 65 ++ vrclient_x64/gen_wrapper.py | 32 +- vrclient_x64/vrclient_main.c | 39 +- vrclient_x64/winIVRApplications.c | 286 +++++ vrclient_x64/winIVRChaperone.c | 67 ++ vrclient_x64/winIVRChaperoneSetup.c | 86 ++ vrclient_x64/winIVRClientCore.c | 64 ++ vrclient_x64/winIVRCompositor.c | 947 +++++++++++++++++ vrclient_x64/winIVRDriverManager.c | 28 + vrclient_x64/winIVRExtendedDisplay.c | 29 + vrclient_x64/winIVRNotifications.c | 55 + vrclient_x64/winIVROverlay.c | 1299 +++++++++++++++++++++++ vrclient_x64/winIVRRenderModels.c | 146 +++ vrclient_x64/winIVRResources.c | 28 + vrclient_x64/winIVRScreenshots.c | 33 + vrclient_x64/winIVRSettings.c | 74 ++ vrclient_x64/winIVRSystem.c | 870 +++++++++++++++ vrclient_x64/winIVRTrackedCamera.c | 112 ++ vrclient_x64/win_constructors.h | 72 ++ vrclient_x64/win_constructors_table.dat | 72 ++ vrclient_x64/win_destructors.h | 72 ++ 22 files changed, 4476 insertions(+), 4 deletions(-) create mode 100644 vrclient_x64/flatapi.h diff --git a/vrclient_x64/cxx.h b/vrclient_x64/cxx.h index 67bc2c5b..5ee17132 100644 --- a/vrclient_x64/cxx.h +++ b/vrclient_x64/cxx.h @@ -37,7 +37,7 @@ #define THISCALL(func) __thiscall_ ## func #define THISCALL_NAME(func) __ASM_NAME("__thiscall_" #func) -#define __thiscall __stdcall +#define __thiscall __stdcall __attribute__((__force_align_arg_pointer__)) #define DEFINE_THISCALL_WRAPPER(func,args) \ extern void THISCALL(func)(void); \ __ASM_GLOBAL_FUNC(__thiscall_ ## func, \ @@ -49,7 +49,7 @@ #define THISCALL(func) func #define THISCALL_NAME(func) __ASM_NAME(#func) -#define __thiscall __cdecl +#define __thiscall __cdecl __attribute__((__force_align_arg_pointer__)) #define DEFINE_THISCALL_WRAPPER(func,args) /* nothing */ #endif /* __i386__ */ diff --git a/vrclient_x64/flatapi.h b/vrclient_x64/flatapi.h new file mode 100644 index 00000000..00a14ce7 --- /dev/null +++ b/vrclient_x64/flatapi.h @@ -0,0 +1,65 @@ +/* asm thunks for the flat (FnTable) API */ + +extern void call_flat_method(void); +#ifdef __i386__ +#include "pshpack1.h" +struct thunk +{ + BYTE mov_ecx; + void *this; + BYTE mov_edx; + void *proc; + BYTE jmp; + LONG call_flat; + BYTE nop; +}; +#include "poppack.h" + +static inline void init_thunk( struct thunk *thunk, void *this, void *proc ) +{ + thunk->mov_ecx = 0xb9; + thunk->this = this; + thunk->mov_edx = 0xba; + thunk->proc = proc; + thunk->jmp = 0xe9; + thunk->call_flat = (char *)call_flat_method - (char *)(&thunk->call_flat + 1); +} + +#else + +#include "pshpack1.h" +struct thunk +{ + BYTE mov_r10[2]; + void *this; + BYTE mov_r11[2]; + void *proc; + BYTE mov_rax[2]; + void *call_flat; + BYTE jmp_rax[2]; +}; +#include "poppack.h" + +static const struct thunk thunk_template = +{ + { 0x49, 0xba }, 0, /* movq This, %r10 */ + { 0x49, 0xbb }, 0, /* movq proc, %r11 */ + { 0x48, 0xb8 }, 0, /* movq call_thunk, %rax */ + { 0xff, 0xe0 } /* jmp *%rax */ +}; + +static inline void init_thunk( struct thunk *thunk, void *this, void *proc ) +{ + *thunk = thunk_template; + thunk->this = this; + thunk->proc = proc; + thunk->call_flat = call_flat_method; +} + +#endif + +static inline struct thunk *alloc_thunks( unsigned int count ) +{ + return VirtualAlloc(NULL, count * sizeof(struct thunk), + MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); +} diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py index bc37342a..16e3d058 100755 --- a/vrclient_x64/gen_wrapper.py +++ b/vrclient_x64/gen_wrapper.py @@ -422,6 +422,8 @@ def handle_class(sdkver, classnode): #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); """) @@ -446,7 +448,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient); winclassname = "win%s_%s" % (classnode.spelling, iface_version) cfile.write("#include \"%s.h\"\n\n" % cppname) cfile.write("typedef struct __%s {\n" % winclassname) - cfile.write(" vtable_ptr *vtable;\n") + cfile.write(" vtable_ptr *vtable;\n") # make sure to keep this first (flat API depends on it) cfile.write(" void *linux_side;\n") for classname_pattern, user_data_type, _ in method_overrides_data: if classname_pattern in classnode.spelling: @@ -484,17 +486,45 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient); break cfile.write(" HeapFree(GetProcessHeap(), 0, object);\n}\n\n") + # flat (FnTable) API + cfile.write("%s *create_%s_FnTable(void *linux_side)\n{\n" % (winclassname, winclassname)) + cfile.write(" %s *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(%s));\n" % (winclassname, winclassname)) + cfile.write(" struct thunk *thunks = alloc_thunks(%d);\n" % len(methods)) + cfile.write(" struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, %d * sizeof(*vtable));\n" % len(methods)) + cfile.write(" int i;\n\n") + cfile.write(" TRACE(\"-> %p, vtable %p, thunks %p\\n\", r, vtable, thunks);\n") + for i in range(len(methods)): + cfile.write(" init_thunk(&thunks[%d], r, %s_%s);\n" %(i, winclassname, methods[i])) + cfile.write(" for (i = 0; i < %d; i++)\n" % len(methods)) + cfile.write(" vtable[i] = &thunks[i];\n") + cfile.write(" r->linux_side = linux_side;\n") + cfile.write(" r->vtable = (void *)vtable;\n") + cfile.write(" return r;\n}\n\n") + cfile.write("void destroy_%s_FnTable(void *object)\n{\n" % winclassname) + cfile.write(" %s *win_object = object;\n" % winclassname) + cfile.write(" TRACE(\"%p\\n\", win_object);\n") + for classname_pattern, user_data_type, user_data_destructor in method_overrides_data: + if user_data_destructor and classname_pattern in classnode.spelling: + cfile.write(" %s(&win_object->user_data);\n" % user_data_destructor) + break + cfile.write(" VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);\n") + cfile.write(" HeapFree(GetProcessHeap(), 0, win_object->vtable);\n") + cfile.write(" HeapFree(GetProcessHeap(), 0, win_object);\n}\n\n") + cpp.write("#ifdef __cplusplus\n}\n#endif\n") cpp_h.write("#ifdef __cplusplus\n}\n#endif\n") constructors = open("win_constructors.h", "a") constructors.write("extern void *create_%s(void *);\n" % winclassname) + constructors.write("extern void *create_%s_FnTable(void *);\n" % winclassname) destructors = open("win_destructors.h", "a") destructors.write("extern void destroy_%s(void *);\n" % winclassname) + destructors.write("extern void destroy_%s_FnTable(void *);\n" % winclassname) constructors = open("win_constructors_table.dat", "a") constructors.write(" {\"%s\", &create_%s, &destroy_%s},\n" % (iface_version, winclassname, winclassname)) + constructors.write(" {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (iface_version, winclassname, winclassname)) if iface_version in aliases.keys(): for alias in aliases[iface_version]: constructors.write(" {\"%s\", &create_%s}, /* alias */\n" % (alias, winclassname)) diff --git a/vrclient_x64/vrclient_main.c b/vrclient_x64/vrclient_main.c index ce0bc480..1ad827e9 100644 --- a/vrclient_x64/vrclient_main.c +++ b/vrclient_x64/vrclient_main.c @@ -23,6 +23,8 @@ #include "wined3d-interop.h" +#include "flatapi.h" + #include "cppIVRCompositor_IVRCompositor_021.h" #include "cppIVRCompositor_IVRCompositor_022.h" @@ -242,6 +244,7 @@ void *ivrclientcore_get_generic_interface(void *(*cpp_func)(void *, const char * void *linux_side, const char *name_and_version, EVRInitError *error, unsigned int version, struct client_core_data *user_data) { + const char *cpp_name_and_version = name_and_version; struct generic_interface *iface; pfn_dtor destructor; void *win_object; @@ -249,7 +252,12 @@ void *ivrclientcore_get_generic_interface(void *(*cpp_func)(void *, const char * TRACE("%p, %p, %p\n", linux_side, name_and_version, error); - if (!(object = cpp_func(linux_side, name_and_version, error))) + /* In theory we could pass this along, but we'd have to generate a separate + * set of thunks for it. Hopefully this will work as it is. */ + if (name_and_version && !strncmp(name_and_version, "FnTable:", 8)) + cpp_name_and_version += 8; + + if (!(object = cpp_func(linux_side, cpp_name_and_version, error))) { WARN("Failed to create %s.\n", name_and_version); return NULL; @@ -279,6 +287,8 @@ void *ivrclientcore_get_generic_interface(void *(*cpp_func)(void *, const char * LeaveCriticalSection(&user_data->critical_section); } + if (name_and_version && !strncmp(name_and_version, "FnTable:", 8)) + return *((void **)win_object); return win_object; } @@ -874,3 +884,30 @@ void destroy_compositor_data(struct compositor_data *data) wined3d_device->lpVtbl->wait_idle(wined3d_device); } } + +/* call_flat_method() definition */ +#ifdef __i386__ +asm(".text\n\t" + ".align 4\n\t" + ".globl call_flat_method\n\t" + ".type call_flat_method, @function\n" + "call_flat_method:\n\t" + "popl %eax\n\t" + "pushl %ecx\n\t" + "pushl %eax\n\t" + "jmp *%edx"); +#else +asm(".text\n\t" + ".align 4\n\t" + ".globl call_flat_method\n\t" + ".type call_flat_method, @function\n" + "call_flat_method:\n\t" + "popq %rax\n\t" // return address + "pushq %r9\n\t" + "pushq %rax\n\t" + "movq %r8, %r9\n\t" // shift over arguments + "movq %rdx, %r8\n\t" + "movq %rcx, %rdx\n\t" + "movq %r10, %rcx\n\t" // add This pointer + "jmp *%r11"); +#endif diff --git a/vrclient_x64/winIVRApplications.c b/vrclient_x64/winIVRApplications.c index 02127bfc..d366d1e8 100644 --- a/vrclient_x64/winIVRApplications.c +++ b/vrclient_x64/winIVRApplications.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRApplications_IVRApplications_006.h" @@ -297,6 +299,61 @@ void destroy_winIVRApplications_IVRApplications_006(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_006 *create_winIVRApplications_IVRApplications_006_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_006)); + struct thunk *thunks = alloc_thunks(31); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 31 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_006_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_006_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_006_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_006_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_006_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_006_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_006_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_006_LaunchTemplateApplication); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_006_LaunchApplicationFromMimeType); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_006_LaunchDashboardOverlay); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_006_CancelApplicationLaunch); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_006_IdentifyApplication); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_006_GetApplicationProcessId); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_006_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_006_GetApplicationPropertyString); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_006_GetApplicationPropertyBool); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_006_GetApplicationPropertyUint64); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_006_SetApplicationAutoLaunch); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_006_GetApplicationAutoLaunch); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_006_SetDefaultApplicationForMimeType); + init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_006_GetDefaultApplicationForMimeType); + init_thunk(&thunks[21], r, winIVRApplications_IVRApplications_006_GetApplicationSupportedMimeTypes); + init_thunk(&thunks[22], r, winIVRApplications_IVRApplications_006_GetApplicationsThatSupportMimeType); + init_thunk(&thunks[23], r, winIVRApplications_IVRApplications_006_GetApplicationLaunchArguments); + init_thunk(&thunks[24], r, winIVRApplications_IVRApplications_006_GetStartingApplication); + init_thunk(&thunks[25], r, winIVRApplications_IVRApplications_006_GetTransitionState); + init_thunk(&thunks[26], r, winIVRApplications_IVRApplications_006_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[27], r, winIVRApplications_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum); + init_thunk(&thunks[28], r, winIVRApplications_IVRApplications_006_IsQuitUserPromptRequested); + init_thunk(&thunks[29], r, winIVRApplications_IVRApplications_006_LaunchInternalProcess); + init_thunk(&thunks[30], r, winIVRApplications_IVRApplications_006_GetCurrentSceneProcessId); + for (i = 0; i < 31; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_006_FnTable(void *object) +{ + winIVRApplications_IVRApplications_006 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRApplications_IVRApplications_005.h" typedef struct __winIVRApplications_IVRApplications_005 { @@ -522,6 +579,54 @@ void destroy_winIVRApplications_IVRApplications_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_005 *create_winIVRApplications_IVRApplications_005_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_005)); + struct thunk *thunks = alloc_thunks(24); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 24 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_005_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_005_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_005_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_005_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_005_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_005_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_005_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_005_LaunchTemplateApplication); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_005_LaunchDashboardOverlay); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_005_CancelApplicationLaunch); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_005_IdentifyApplication); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_005_GetApplicationProcessId); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_005_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_005_GetApplicationPropertyString); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_005_GetApplicationPropertyBool); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_005_GetApplicationPropertyUint64); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_005_SetApplicationAutoLaunch); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_005_GetApplicationAutoLaunch); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_005_GetStartingApplication); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_005_GetTransitionState); + init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_005_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[21], r, winIVRApplications_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum); + init_thunk(&thunks[22], r, winIVRApplications_IVRApplications_005_IsQuitUserPromptRequested); + init_thunk(&thunks[23], r, winIVRApplications_IVRApplications_005_LaunchInternalProcess); + for (i = 0; i < 24; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_005_FnTable(void *object) +{ + winIVRApplications_IVRApplications_005 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRApplications_IVRApplications_004.h" typedef struct __winIVRApplications_IVRApplications_004 { @@ -739,6 +844,53 @@ void destroy_winIVRApplications_IVRApplications_004(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_004 *create_winIVRApplications_IVRApplications_004_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_004)); + struct thunk *thunks = alloc_thunks(23); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 23 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_004_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_004_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_004_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_004_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_004_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_004_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_004_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_004_LaunchDashboardOverlay); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_004_CancelApplicationLaunch); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_004_IdentifyApplication); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_004_GetApplicationProcessId); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_004_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_004_GetApplicationPropertyString); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_004_GetApplicationPropertyBool); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_004_GetApplicationPropertyUint64); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_004_SetApplicationAutoLaunch); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_004_GetApplicationAutoLaunch); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_004_GetStartingApplication); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_004_GetTransitionState); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_004_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_004_GetApplicationsTransitionStateNameFromEnum); + init_thunk(&thunks[21], r, winIVRApplications_IVRApplications_004_IsQuitUserPromptRequested); + init_thunk(&thunks[22], r, winIVRApplications_IVRApplications_004_LaunchInternalProcess); + for (i = 0; i < 23; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_004_FnTable(void *object) +{ + winIVRApplications_IVRApplications_004 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRApplications_IVRApplications_003.h" typedef struct __winIVRApplications_IVRApplications_003 { @@ -940,6 +1092,51 @@ void destroy_winIVRApplications_IVRApplications_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_003 *create_winIVRApplications_IVRApplications_003_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_003)); + struct thunk *thunks = alloc_thunks(21); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 21 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_003_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_003_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_003_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_003_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_003_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_003_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_003_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_003_LaunchDashboardOverlay); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_003_IdentifyApplication); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_003_GetApplicationProcessId); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_003_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_003_GetApplicationPropertyString); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_003_GetApplicationPropertyBool); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_003_GetApplicationPropertyUint64); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_003_SetApplicationAutoLaunch); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_003_GetApplicationAutoLaunch); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_003_GetStartingApplication); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_003_GetTransitionState); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_003_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_003_GetApplicationsTransitionStateNameFromEnum); + init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_003_IsQuitUserPromptRequested); + for (i = 0; i < 21; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_003_FnTable(void *object) +{ + winIVRApplications_IVRApplications_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRApplications_IVRApplications_002.h" typedef struct __winIVRApplications_IVRApplications_002 { @@ -1133,6 +1330,50 @@ void destroy_winIVRApplications_IVRApplications_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_002 *create_winIVRApplications_IVRApplications_002_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_002)); + struct thunk *thunks = alloc_thunks(20); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 20 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_002_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_002_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_002_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_002_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_002_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_002_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_002_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_002_LaunchDashboardOverlay); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_002_IdentifyApplication); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_002_GetApplicationProcessId); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_002_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_002_GetApplicationPropertyString); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_002_GetApplicationPropertyBool); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_002_SetApplicationAutoLaunch); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_002_GetApplicationAutoLaunch); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_002_GetStartingApplication); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_002_GetTransitionState); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_002_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_002_GetApplicationsTransitionStateNameFromEnum); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_002_IsQuitUserPromptRequested); + for (i = 0; i < 20; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_002_FnTable(void *object) +{ + winIVRApplications_IVRApplications_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRApplications_IVRApplications_001.h" typedef struct __winIVRApplications_IVRApplications_001 { @@ -1334,3 +1575,48 @@ void destroy_winIVRApplications_IVRApplications_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRApplications_IVRApplications_001 *create_winIVRApplications_IVRApplications_001_FnTable(void *linux_side) +{ + winIVRApplications_IVRApplications_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_001)); + struct thunk *thunks = alloc_thunks(21); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 21 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_001_AddApplicationManifest); + init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_001_RemoveApplicationManifest); + init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_001_IsApplicationInstalled); + init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_001_GetApplicationCount); + init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_001_GetApplicationKeyByIndex); + init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_001_GetApplicationKeyByProcessId); + init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_001_LaunchApplication); + init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_001_LaunchDashboardOverlay); + init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_001_IdentifyApplication); + init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_001_GetApplicationProcessId); + init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_001_GetApplicationsErrorNameFromEnum); + init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_001_GetApplicationPropertyString); + init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_001_GetApplicationPropertyBool); + init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_001_GetHomeApplication); + init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_001_SetHomeApplication); + init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_001_SetApplicationAutoLaunch); + init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_001_GetApplicationAutoLaunch); + init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_001_GetStartingApplication); + init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_001_GetTransitionState); + init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_001_PerformApplicationPrelaunchCheck); + init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_001_GetApplicationsTransitionStateNameFromEnum); + for (i = 0; i < 21; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRApplications_IVRApplications_001_FnTable(void *object) +{ + winIVRApplications_IVRApplications_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRChaperone.c b/vrclient_x64/winIVRChaperone.c index 8af58273..6dca3780 100644 --- a/vrclient_x64/winIVRChaperone.c +++ b/vrclient_x64/winIVRChaperone.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRChaperone_IVRChaperone_003.h" @@ -113,6 +115,38 @@ void destroy_winIVRChaperone_IVRChaperone_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRChaperone_IVRChaperone_003 *create_winIVRChaperone_IVRChaperone_003_FnTable(void *linux_side) +{ + winIVRChaperone_IVRChaperone_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRChaperone_IVRChaperone_003)); + struct thunk *thunks = alloc_thunks(8); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 8 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRChaperone_IVRChaperone_003_GetCalibrationState); + init_thunk(&thunks[1], r, winIVRChaperone_IVRChaperone_003_GetPlayAreaSize); + init_thunk(&thunks[2], r, winIVRChaperone_IVRChaperone_003_GetPlayAreaRect); + init_thunk(&thunks[3], r, winIVRChaperone_IVRChaperone_003_ReloadInfo); + init_thunk(&thunks[4], r, winIVRChaperone_IVRChaperone_003_SetSceneColor); + init_thunk(&thunks[5], r, winIVRChaperone_IVRChaperone_003_GetBoundsColor); + init_thunk(&thunks[6], r, winIVRChaperone_IVRChaperone_003_AreBoundsVisible); + init_thunk(&thunks[7], r, winIVRChaperone_IVRChaperone_003_ForceBoundsVisible); + for (i = 0; i < 8; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRChaperone_IVRChaperone_003_FnTable(void *object) +{ + winIVRChaperone_IVRChaperone_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRChaperone_IVRChaperone_002.h" typedef struct __winIVRChaperone_IVRChaperone_002 { @@ -218,3 +252,36 @@ void destroy_winIVRChaperone_IVRChaperone_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRChaperone_IVRChaperone_002 *create_winIVRChaperone_IVRChaperone_002_FnTable(void *linux_side) +{ + winIVRChaperone_IVRChaperone_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRChaperone_IVRChaperone_002)); + struct thunk *thunks = alloc_thunks(9); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 9 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRChaperone_IVRChaperone_002_GetCalibrationState); + init_thunk(&thunks[1], r, winIVRChaperone_IVRChaperone_002_GetSoftBoundsInfo); + init_thunk(&thunks[2], r, winIVRChaperone_IVRChaperone_002_GetHardBoundsInfo); + init_thunk(&thunks[3], r, winIVRChaperone_IVRChaperone_002_GetSeatedBoundsInfo); + init_thunk(&thunks[4], r, winIVRChaperone_IVRChaperone_002_ReloadInfo); + init_thunk(&thunks[5], r, winIVRChaperone_IVRChaperone_002_SetSceneColor); + init_thunk(&thunks[6], r, winIVRChaperone_IVRChaperone_002_GetBoundsColor); + init_thunk(&thunks[7], r, winIVRChaperone_IVRChaperone_002_AreBoundsVisible); + init_thunk(&thunks[8], r, winIVRChaperone_IVRChaperone_002_ForceBoundsVisible); + for (i = 0; i < 9; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRChaperone_IVRChaperone_002_FnTable(void *object) +{ + winIVRChaperone_IVRChaperone_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRChaperoneSetup.c b/vrclient_x64/winIVRChaperoneSetup.c index e62aa2e4..f3f2c714 100644 --- a/vrclient_x64/winIVRChaperoneSetup.c +++ b/vrclient_x64/winIVRChaperoneSetup.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRChaperoneSetup_IVRChaperoneSetup_005.h" @@ -209,6 +211,50 @@ void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRChaperoneSetup_IVRChaperoneSetup_005 *create_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *linux_side) +{ + winIVRChaperoneSetup_IVRChaperoneSetup_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRChaperoneSetup_IVRChaperoneSetup_005)); + struct thunk *thunks = alloc_thunks(20); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 20 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_CommitWorkingCopy); + init_thunk(&thunks[1], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_RevertWorkingCopy); + init_thunk(&thunks[2], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetWorkingPlayAreaSize); + init_thunk(&thunks[3], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetWorkingPlayAreaRect); + init_thunk(&thunks[4], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo); + init_thunk(&thunks[5], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo); + init_thunk(&thunks[6], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[7], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose); + init_thunk(&thunks[8], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingPlayAreaSize); + init_thunk(&thunks[9], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo); + init_thunk(&thunks[10], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[11], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose); + init_thunk(&thunks[12], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_ReloadFromDisk); + init_thunk(&thunks[13], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[14], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo); + init_thunk(&thunks[15], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo); + init_thunk(&thunks[16], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo); + init_thunk(&thunks[17], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo); + init_thunk(&thunks[18], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_ExportLiveToBuffer); + init_thunk(&thunks[19], r, winIVRChaperoneSetup_IVRChaperoneSetup_005_ImportFromBufferToWorking); + for (i = 0; i < 20; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *object) +{ + winIVRChaperoneSetup_IVRChaperoneSetup_005 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRChaperoneSetup_IVRChaperoneSetup_004.h" typedef struct __winIVRChaperoneSetup_IVRChaperoneSetup_004 { @@ -370,3 +416,43 @@ void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRChaperoneSetup_IVRChaperoneSetup_004 *create_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable(void *linux_side) +{ + winIVRChaperoneSetup_IVRChaperoneSetup_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRChaperoneSetup_IVRChaperoneSetup_004)); + struct thunk *thunks = alloc_thunks(16); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 16 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_CommitWorkingCopy); + init_thunk(&thunks[1], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_RevertWorkingCopy); + init_thunk(&thunks[2], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetWorkingPlayAreaSize); + init_thunk(&thunks[3], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetWorkingPlayAreaRect); + init_thunk(&thunks[4], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo); + init_thunk(&thunks[5], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo); + init_thunk(&thunks[6], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[7], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose); + init_thunk(&thunks[8], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_SetWorkingPlayAreaSize); + init_thunk(&thunks[9], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo); + init_thunk(&thunks[10], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[11], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose); + init_thunk(&thunks[12], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_ReloadFromDisk); + init_thunk(&thunks[13], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose); + init_thunk(&thunks[14], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_SetWorkingWallTagInfo); + init_thunk(&thunks[15], r, winIVRChaperoneSetup_IVRChaperoneSetup_004_GetLiveWallTagInfo); + for (i = 0; i < 16; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable(void *object) +{ + winIVRChaperoneSetup_IVRChaperoneSetup_004 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRClientCore.c b/vrclient_x64/winIVRClientCore.c index 465bb099..af5db46e 100644 --- a/vrclient_x64/winIVRClientCore.c +++ b/vrclient_x64/winIVRClientCore.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRClientCore_IVRClientCore_003.h" @@ -106,6 +108,37 @@ void destroy_winIVRClientCore_IVRClientCore_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRClientCore_IVRClientCore_003 *create_winIVRClientCore_IVRClientCore_003_FnTable(void *linux_side) +{ + winIVRClientCore_IVRClientCore_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRClientCore_IVRClientCore_003)); + struct thunk *thunks = alloc_thunks(7); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 7 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRClientCore_IVRClientCore_003_Init); + init_thunk(&thunks[1], r, winIVRClientCore_IVRClientCore_003_Cleanup); + init_thunk(&thunks[2], r, winIVRClientCore_IVRClientCore_003_IsInterfaceVersionValid); + init_thunk(&thunks[3], r, winIVRClientCore_IVRClientCore_003_GetGenericInterface); + init_thunk(&thunks[4], r, winIVRClientCore_IVRClientCore_003_BIsHmdPresent); + init_thunk(&thunks[5], r, winIVRClientCore_IVRClientCore_003_GetEnglishStringForHmdError); + init_thunk(&thunks[6], r, winIVRClientCore_IVRClientCore_003_GetIDForVRInitError); + for (i = 0; i < 7; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *object) +{ + winIVRClientCore_IVRClientCore_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRClientCore_IVRClientCore_002.h" typedef struct __winIVRClientCore_IVRClientCore_002 { @@ -196,3 +229,34 @@ void destroy_winIVRClientCore_IVRClientCore_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRClientCore_IVRClientCore_002 *create_winIVRClientCore_IVRClientCore_002_FnTable(void *linux_side) +{ + winIVRClientCore_IVRClientCore_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRClientCore_IVRClientCore_002)); + struct thunk *thunks = alloc_thunks(7); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 7 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRClientCore_IVRClientCore_002_Init); + init_thunk(&thunks[1], r, winIVRClientCore_IVRClientCore_002_Cleanup); + init_thunk(&thunks[2], r, winIVRClientCore_IVRClientCore_002_IsInterfaceVersionValid); + init_thunk(&thunks[3], r, winIVRClientCore_IVRClientCore_002_GetGenericInterface); + init_thunk(&thunks[4], r, winIVRClientCore_IVRClientCore_002_BIsHmdPresent); + init_thunk(&thunks[5], r, winIVRClientCore_IVRClientCore_002_GetEnglishStringForHmdError); + init_thunk(&thunks[6], r, winIVRClientCore_IVRClientCore_002_GetIDForVRInitError); + for (i = 0; i < 7; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRClientCore_IVRClientCore_002_FnTable(void *object) +{ + winIVRClientCore_IVRClientCore_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRCompositor.c b/vrclient_x64/winIVRCompositor.c index 64b8ed44..6177f2b1 100644 --- a/vrclient_x64/winIVRCompositor.c +++ b/vrclient_x64/winIVRCompositor.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRCompositor_IVRCompositor_022.h" @@ -397,6 +399,74 @@ void destroy_winIVRCompositor_IVRCompositor_022(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_022 *create_winIVRCompositor_IVRCompositor_022_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_022 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_022)); + struct thunk *thunks = alloc_thunks(43); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 43 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_022_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_022_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_022_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_022_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_022_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_022_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_022_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_022_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_022_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_022_GetFrameTimings); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_022_GetFrameTimeRemaining); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_022_GetCumulativeStats); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_022_FadeToColor); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_022_GetCurrentFadeColor); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_022_FadeGrid); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_022_GetCurrentGridAlpha); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_022_SetSkyboxOverride); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_022_ClearSkyboxOverride); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_022_CompositorBringToFront); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_022_CompositorGoToBack); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_022_CompositorQuit); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_022_IsFullscreen); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_022_GetCurrentSceneFocusProcess); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_022_GetLastFrameRenderer); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_022_CanRenderScene); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_022_ShowMirrorWindow); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_022_HideMirrorWindow); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_022_IsMirrorWindowVisible); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_022_CompositorDumpImages); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_022_ShouldAppRenderWithLowResources); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_022_ForceInterleavedReprojectionOn); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_022_ForceReconnectProcess); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_022_SuspendRendering); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_022_GetMirrorTextureD3D11); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_022_ReleaseMirrorTextureD3D11); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_022_GetMirrorTextureGL); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_022_ReleaseSharedGLTexture); + init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_022_LockGLSharedTextureForAccess); + init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_022_UnlockGLSharedTextureForAccess); + init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired); + init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_022_GetVulkanDeviceExtensionsRequired); + init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_022_SetExplicitTimingMode); + init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_022_SubmitExplicitTimingData); + for (i = 0; i < 43; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_022_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_022 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_021.h" typedef struct __winIVRCompositor_IVRCompositor_021 { @@ -778,6 +848,74 @@ void destroy_winIVRCompositor_IVRCompositor_021(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_021 *create_winIVRCompositor_IVRCompositor_021_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_021 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_021)); + struct thunk *thunks = alloc_thunks(43); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 43 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_021_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_021_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_021_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_021_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_021_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_021_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_021_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_021_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_021_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_021_GetFrameTimings); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_021_GetFrameTimeRemaining); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_021_GetCumulativeStats); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_021_FadeToColor); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_021_GetCurrentFadeColor); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_021_FadeGrid); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_021_GetCurrentGridAlpha); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_021_SetSkyboxOverride); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_021_ClearSkyboxOverride); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_021_CompositorBringToFront); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_021_CompositorGoToBack); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_021_CompositorQuit); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_021_IsFullscreen); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_021_GetCurrentSceneFocusProcess); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_021_GetLastFrameRenderer); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_021_CanRenderScene); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_021_ShowMirrorWindow); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_021_HideMirrorWindow); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_021_IsMirrorWindowVisible); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_021_CompositorDumpImages); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_021_ShouldAppRenderWithLowResources); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_021_ForceInterleavedReprojectionOn); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_021_ForceReconnectProcess); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_021_SuspendRendering); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_021_GetMirrorTextureD3D11); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_021_ReleaseMirrorTextureD3D11); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_021_GetMirrorTextureGL); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_021_ReleaseSharedGLTexture); + init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_021_LockGLSharedTextureForAccess); + init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_021_UnlockGLSharedTextureForAccess); + init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_021_GetVulkanInstanceExtensionsRequired); + init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_021_GetVulkanDeviceExtensionsRequired); + init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_021_SetExplicitTimingMode); + init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_021_SubmitExplicitTimingData); + for (i = 0; i < 43; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_021_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_021 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_020.h" typedef struct __winIVRCompositor_IVRCompositor_020 { @@ -1143,6 +1281,72 @@ void destroy_winIVRCompositor_IVRCompositor_020(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_020 *create_winIVRCompositor_IVRCompositor_020_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_020 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_020)); + struct thunk *thunks = alloc_thunks(41); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 41 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_020_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_020_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_020_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_020_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_020_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_020_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_020_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_020_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_020_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_020_GetFrameTimings); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_020_GetFrameTimeRemaining); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_020_GetCumulativeStats); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_020_FadeToColor); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_020_GetCurrentFadeColor); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_020_FadeGrid); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_020_GetCurrentGridAlpha); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_020_SetSkyboxOverride); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_020_ClearSkyboxOverride); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_020_CompositorBringToFront); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_020_CompositorGoToBack); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_020_CompositorQuit); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_020_IsFullscreen); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_020_GetCurrentSceneFocusProcess); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_020_GetLastFrameRenderer); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_020_CanRenderScene); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_020_ShowMirrorWindow); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_020_HideMirrorWindow); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_020_IsMirrorWindowVisible); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_020_CompositorDumpImages); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_020_ShouldAppRenderWithLowResources); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_020_ForceInterleavedReprojectionOn); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_020_ForceReconnectProcess); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_020_SuspendRendering); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_020_GetMirrorTextureD3D11); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_020_ReleaseMirrorTextureD3D11); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_020_GetMirrorTextureGL); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_020_ReleaseSharedGLTexture); + init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_020_LockGLSharedTextureForAccess); + init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_020_UnlockGLSharedTextureForAccess); + init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_020_GetVulkanInstanceExtensionsRequired); + init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_020_GetVulkanDeviceExtensionsRequired); + for (i = 0; i < 41; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_020_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_020 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_019.h" typedef struct __winIVRCompositor_IVRCompositor_019 { @@ -1500,6 +1704,71 @@ void destroy_winIVRCompositor_IVRCompositor_019(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_019 *create_winIVRCompositor_IVRCompositor_019_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_019 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_019)); + struct thunk *thunks = alloc_thunks(40); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 40 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_019_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_019_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_019_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_019_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_019_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_019_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_019_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_019_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_019_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_019_GetFrameTimings); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_019_GetFrameTimeRemaining); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_019_GetCumulativeStats); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_019_FadeToColor); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_019_GetCurrentFadeColor); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_019_FadeGrid); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_019_GetCurrentGridAlpha); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_019_SetSkyboxOverride); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_019_ClearSkyboxOverride); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_019_CompositorBringToFront); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_019_CompositorGoToBack); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_019_CompositorQuit); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_019_IsFullscreen); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_019_GetCurrentSceneFocusProcess); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_019_GetLastFrameRenderer); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_019_CanRenderScene); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_019_ShowMirrorWindow); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_019_HideMirrorWindow); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_019_IsMirrorWindowVisible); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_019_CompositorDumpImages); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_019_ShouldAppRenderWithLowResources); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_019_ForceInterleavedReprojectionOn); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_019_ForceReconnectProcess); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_019_SuspendRendering); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_019_GetMirrorTextureD3D11); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_019_GetMirrorTextureGL); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_019_ReleaseSharedGLTexture); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_019_LockGLSharedTextureForAccess); + init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_019_UnlockGLSharedTextureForAccess); + init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_019_GetVulkanInstanceExtensionsRequired); + init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_019_GetVulkanDeviceExtensionsRequired); + for (i = 0; i < 40; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_019_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_019 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_018.h" typedef struct __winIVRCompositor_IVRCompositor_018 { @@ -1841,6 +2110,69 @@ void destroy_winIVRCompositor_IVRCompositor_018(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_018 *create_winIVRCompositor_IVRCompositor_018_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_018 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_018)); + struct thunk *thunks = alloc_thunks(38); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 38 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_018_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_018_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_018_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_018_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_018_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_018_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_018_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_018_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_018_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_018_GetFrameTimings); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_018_GetFrameTimeRemaining); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_018_GetCumulativeStats); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_018_FadeToColor); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_018_GetCurrentFadeColor); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_018_FadeGrid); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_018_GetCurrentGridAlpha); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_018_SetSkyboxOverride); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_018_ClearSkyboxOverride); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_018_CompositorBringToFront); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_018_CompositorGoToBack); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_018_CompositorQuit); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_018_IsFullscreen); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_018_GetCurrentSceneFocusProcess); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_018_GetLastFrameRenderer); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_018_CanRenderScene); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_018_ShowMirrorWindow); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_018_HideMirrorWindow); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_018_IsMirrorWindowVisible); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_018_CompositorDumpImages); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_018_ShouldAppRenderWithLowResources); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_018_ForceInterleavedReprojectionOn); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_018_ForceReconnectProcess); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_018_SuspendRendering); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_018_GetMirrorTextureD3D11); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_018_GetMirrorTextureGL); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_018_ReleaseSharedGLTexture); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_018_LockGLSharedTextureForAccess); + init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_018_UnlockGLSharedTextureForAccess); + for (i = 0; i < 38; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_018 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_016.h" typedef struct __winIVRCompositor_IVRCompositor_016 { @@ -2157,6 +2489,66 @@ void destroy_winIVRCompositor_IVRCompositor_016(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_016 *create_winIVRCompositor_IVRCompositor_016_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_016 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_016)); + struct thunk *thunks = alloc_thunks(35); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 35 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_016_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_016_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_016_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_016_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_016_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_016_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_016_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_016_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_016_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_016_GetFrameTimeRemaining); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_016_GetCumulativeStats); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_016_FadeToColor); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_016_FadeGrid); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_016_SetSkyboxOverride); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_016_ClearSkyboxOverride); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_016_CompositorBringToFront); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_016_CompositorGoToBack); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_016_CompositorQuit); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_016_IsFullscreen); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_016_GetCurrentSceneFocusProcess); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_016_GetLastFrameRenderer); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_016_CanRenderScene); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_016_ShowMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_016_HideMirrorWindow); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_016_IsMirrorWindowVisible); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_016_CompositorDumpImages); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_016_ShouldAppRenderWithLowResources); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_016_ForceInterleavedReprojectionOn); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_016_ForceReconnectProcess); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_016_SuspendRendering); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_016_GetMirrorTextureD3D11); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_016_GetMirrorTextureGL); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_016_ReleaseSharedGLTexture); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_016_LockGLSharedTextureForAccess); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_016_UnlockGLSharedTextureForAccess); + for (i = 0; i < 35; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_016_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_016 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_015.h" typedef struct __winIVRCompositor_IVRCompositor_015 { @@ -2489,6 +2881,68 @@ void destroy_winIVRCompositor_IVRCompositor_015(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_015 *create_winIVRCompositor_IVRCompositor_015_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_015 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_015)); + struct thunk *thunks = alloc_thunks(37); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 37 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_015_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_015_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_015_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_015_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_015_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_015_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_015_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_015_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_015_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_015_GetFrameTimeRemaining); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_015_GetCumulativeStats); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_015_FadeToColor); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_015_FadeGrid); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_015_SetSkyboxOverride); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_015_ClearSkyboxOverride); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_015_CompositorBringToFront); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_015_CompositorGoToBack); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_015_CompositorQuit); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_015_IsFullscreen); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_015_GetCurrentSceneFocusProcess); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_015_GetLastFrameRenderer); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_015_CanRenderScene); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_015_ShowMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_015_HideMirrorWindow); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_015_IsMirrorWindowVisible); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_015_CompositorDumpImages); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_015_ShouldAppRenderWithLowResources); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_015_ForceInterleavedReprojectionOn); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_015_ForceReconnectProcess); + init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_015_SuspendRendering); + init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_015_RequestScreenshot); + init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_015_GetCurrentScreenshotType); + init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_015_GetMirrorTextureD3D11); + init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_015_GetMirrorTextureGL); + init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_015_ReleaseSharedGLTexture); + init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_015_LockGLSharedTextureForAccess); + init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_015_UnlockGLSharedTextureForAccess); + for (i = 0; i < 37; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_015_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_015 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_014.h" typedef struct __winIVRCompositor_IVRCompositor_014 { @@ -2757,6 +3211,60 @@ void destroy_winIVRCompositor_IVRCompositor_014(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_014 *create_winIVRCompositor_IVRCompositor_014_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_014 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_014)); + struct thunk *thunks = alloc_thunks(29); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 29 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_014_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_014_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_014_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_014_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_014_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_014_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_014_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_014_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_014_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_014_GetFrameTimeRemaining); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_014_FadeToColor); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_014_FadeGrid); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_014_SetSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_014_ClearSkyboxOverride); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_014_CompositorBringToFront); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_014_CompositorGoToBack); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_014_CompositorQuit); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_014_IsFullscreen); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_014_GetCurrentSceneFocusProcess); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_014_GetLastFrameRenderer); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_014_CanRenderScene); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_014_ShowMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_014_HideMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_014_IsMirrorWindowVisible); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_014_CompositorDumpImages); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_014_ShouldAppRenderWithLowResources); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_014_ForceInterleavedReprojectionOn); + init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_014_ForceReconnectProcess); + init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_014_SuspendRendering); + for (i = 0; i < 29; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_014_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_014 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_013.h" typedef struct __winIVRCompositor_IVRCompositor_013 { @@ -3009,6 +3517,58 @@ void destroy_winIVRCompositor_IVRCompositor_013(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_013 *create_winIVRCompositor_IVRCompositor_013_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_013 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_013)); + struct thunk *thunks = alloc_thunks(27); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 27 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_013_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_013_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_013_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_013_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_013_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_013_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_013_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_013_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_013_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_013_GetFrameTimeRemaining); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_013_FadeToColor); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_013_FadeGrid); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_013_SetSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_013_ClearSkyboxOverride); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_013_CompositorBringToFront); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_013_CompositorGoToBack); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_013_CompositorQuit); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_013_IsFullscreen); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_013_GetCurrentSceneFocusProcess); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_013_GetLastFrameRenderer); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_013_CanRenderScene); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_013_ShowMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_013_HideMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_013_IsMirrorWindowVisible); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_013_CompositorDumpImages); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_013_ShouldAppRenderWithLowResources); + init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_013_ForceInterleavedReprojectionOn); + for (i = 0; i < 27; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_013_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_013 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_012.h" typedef struct __winIVRCompositor_IVRCompositor_012 { @@ -3253,6 +3813,57 @@ void destroy_winIVRCompositor_IVRCompositor_012(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_012 *create_winIVRCompositor_IVRCompositor_012_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_012 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_012)); + struct thunk *thunks = alloc_thunks(26); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 26 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_012_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_012_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_012_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_012_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_012_GetLastPoseForTrackedDeviceIndex); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_012_Submit); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_012_ClearLastSubmittedFrame); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_012_PostPresentHandoff); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_012_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_012_GetFrameTimeRemaining); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_012_FadeToColor); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_012_FadeGrid); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_012_SetSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_012_ClearSkyboxOverride); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_012_CompositorBringToFront); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_012_CompositorGoToBack); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_012_CompositorQuit); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_012_IsFullscreen); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_012_GetCurrentSceneFocusProcess); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_012_GetLastFrameRenderer); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_012_CanRenderScene); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_012_ShowMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_012_HideMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_012_IsMirrorWindowVisible); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_012_CompositorDumpImages); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_012_ShouldAppRenderWithLowResources); + for (i = 0; i < 26; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_012_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_012 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_011.h" typedef struct __winIVRCompositor_IVRCompositor_011 { @@ -3481,6 +4092,55 @@ void destroy_winIVRCompositor_IVRCompositor_011(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_011 *create_winIVRCompositor_IVRCompositor_011_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_011 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_011)); + struct thunk *thunks = alloc_thunks(24); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 24 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_011_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_011_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_011_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_011_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_011_Submit); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_011_ClearLastSubmittedFrame); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_011_PostPresentHandoff); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_011_GetFrameTiming); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_011_GetFrameTimeRemaining); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_011_FadeToColor); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_011_FadeGrid); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_011_SetSkyboxOverride); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_011_ClearSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_011_CompositorBringToFront); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_011_CompositorGoToBack); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_011_CompositorQuit); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_011_IsFullscreen); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_011_GetCurrentSceneFocusProcess); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_011_GetLastFrameRenderer); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_011_CanRenderScene); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_011_ShowMirrorWindow); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_011_HideMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_011_IsMirrorWindowVisible); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_011_CompositorDumpImages); + for (i = 0; i < 24; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_011_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_011 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_010.h" typedef struct __winIVRCompositor_IVRCompositor_010 { @@ -3709,6 +4369,55 @@ void destroy_winIVRCompositor_IVRCompositor_010(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_010 *create_winIVRCompositor_IVRCompositor_010_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_010 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_010)); + struct thunk *thunks = alloc_thunks(24); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 24 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_010_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_010_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_010_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_010_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_010_Submit); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_010_ClearLastSubmittedFrame); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_010_PostPresentHandoff); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_010_GetFrameTiming); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_010_GetFrameTimeRemaining); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_010_FadeToColor); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_010_FadeGrid); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_010_SetSkyboxOverride); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_010_ClearSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_010_CompositorBringToFront); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_010_CompositorGoToBack); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_010_CompositorQuit); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_010_IsFullscreen); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_010_GetCurrentSceneFocusProcess); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_010_GetLastFrameRenderer); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_010_CanRenderScene); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_010_ShowMirrorWindow); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_010_HideMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_010_IsMirrorWindowVisible); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_010_CompositorDumpImages); + for (i = 0; i < 24; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_010_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_010 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_009.h" typedef struct __winIVRCompositor_IVRCompositor_009 { @@ -3937,6 +4646,55 @@ void destroy_winIVRCompositor_IVRCompositor_009(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_009 *create_winIVRCompositor_IVRCompositor_009_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_009 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_009)); + struct thunk *thunks = alloc_thunks(24); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 24 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_009_SetTrackingSpace); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_009_GetTrackingSpace); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_009_WaitGetPoses); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_009_GetLastPoses); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_009_Submit); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_009_ClearLastSubmittedFrame); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_009_PostPresentHandoff); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_009_GetFrameTiming); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_009_GetFrameTimeRemaining); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_009_FadeToColor); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_009_FadeGrid); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_009_SetSkyboxOverride); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_009_ClearSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_009_CompositorBringToFront); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_009_CompositorGoToBack); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_009_CompositorQuit); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_009_IsFullscreen); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_009_GetCurrentSceneFocusProcess); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_009_GetLastFrameRenderer); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_009_CanRenderScene); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_009_ShowMirrorWindow); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_009_HideMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_009_IsMirrorWindowVisible); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_009_CompositorDumpImages); + for (i = 0; i < 24; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_009_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_009 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_008.h" typedef struct __winIVRCompositor_IVRCompositor_008 { @@ -4181,6 +4939,57 @@ void destroy_winIVRCompositor_IVRCompositor_008(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_008 *create_winIVRCompositor_IVRCompositor_008_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_008 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_008)); + struct thunk *thunks = alloc_thunks(26); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 26 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_008_GetLastError); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_008_SetVSync); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_008_GetVSync); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_008_SetGamma); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_008_GetGamma); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_008_WaitGetPoses); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_008_Submit); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_008_ClearLastSubmittedFrame); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_008_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_008_FadeToColor); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_008_FadeGrid); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_008_SetSkyboxOverride); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_008_ClearSkyboxOverride); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_008_CompositorBringToFront); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_008_CompositorGoToBack); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_008_CompositorQuit); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_008_IsFullscreen); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_008_SetTrackingSpace); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_008_GetTrackingSpace); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_008_GetCurrentSceneFocusProcess); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_008_CanRenderScene); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_008_ShowMirrorWindow); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_008_HideMirrorWindow); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_008_CompositorDumpImages); + init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_008_GetFrameTimeRemaining); + init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_008_GetLastFrameRenderer); + for (i = 0; i < 26; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_008_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_008 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_007.h" typedef struct __winIVRCompositor_IVRCompositor_007 { @@ -4369,6 +5178,50 @@ void destroy_winIVRCompositor_IVRCompositor_007(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_007 *create_winIVRCompositor_IVRCompositor_007_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_007)); + struct thunk *thunks = alloc_thunks(19); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 19 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_007_GetLastError); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_007_SetVSync); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_007_GetVSync); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_007_SetGamma); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_007_GetGamma); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_007_WaitGetPoses); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_007_Submit); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_007_ClearLastSubmittedFrame); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_007_GetFrameTiming); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_007_FadeToColor); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_007_FadeGrid); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_007_CompositorBringToFront); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_007_CompositorGoToBack); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_007_CompositorQuit); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_007_IsFullscreen); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_007_SetTrackingSpace); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_007_GetTrackingSpace); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_007_GetCurrentSceneFocusProcess); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_007_CanRenderScene); + for (i = 0; i < 19; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_007_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_007 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_006.h" typedef struct __winIVRCompositor_IVRCompositor_006 { @@ -4565,6 +5418,51 @@ void destroy_winIVRCompositor_IVRCompositor_006(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_006 *create_winIVRCompositor_IVRCompositor_006_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_006)); + struct thunk *thunks = alloc_thunks(20); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 20 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_006_GetLastError); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_006_SetVSync); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_006_GetVSync); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_006_SetGamma); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_006_GetGamma); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_006_SetGraphicsDevice); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_006_WaitGetPoses); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_006_Submit); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_006_ClearLastSubmittedFrame); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_006_GetFrameTiming); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_006_FadeToColor); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_006_FadeGrid); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_006_CompositorBringToFront); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_006_CompositorGoToBack); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_006_CompositorQuit); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_006_IsFullscreen); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_006_SetTrackingSpace); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_006_GetTrackingSpace); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_006_GetCurrentSceneFocusProcess); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_006_CanRenderScene); + for (i = 0; i < 20; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_006_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_006 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRCompositor_IVRCompositor_005.h" typedef struct __winIVRCompositor_IVRCompositor_005 { @@ -4793,3 +5691,52 @@ void destroy_winIVRCompositor_IVRCompositor_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRCompositor_IVRCompositor_005 *create_winIVRCompositor_IVRCompositor_005_FnTable(void *linux_side) +{ + winIVRCompositor_IVRCompositor_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_005)); + struct thunk *thunks = alloc_thunks(24); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 24 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_005_GetLastError); + init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_005_SetVSync); + init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_005_GetVSync); + init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_005_SetGamma); + init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_005_GetGamma); + init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_005_SetGraphicsDevice); + init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_005_WaitGetPoses); + init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_005_Submit); + init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_005_ClearLastSubmittedFrame); + init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_005_GetOverlayDefaults); + init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_005_SetOverlay); + init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_005_SetOverlayRaw); + init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_005_SetOverlayFromFile); + init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_005_ClearOverlay); + init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_005_GetFrameTiming); + init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_005_FadeToColor); + init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_005_FadeGrid); + init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_005_CompositorBringToFront); + init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_005_CompositorGoToBack); + init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_005_CompositorQuit); + init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_005_IsFullscreen); + init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_005_ComputeOverlayIntersection); + init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_005_SetTrackingSpace); + init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_005_GetTrackingSpace); + for (i = 0; i < 24; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRCompositor_IVRCompositor_005_FnTable(void *object) +{ + winIVRCompositor_IVRCompositor_005 *win_object = object; + TRACE("%p\n", win_object); + destroy_compositor_data(&win_object->user_data); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRDriverManager.c b/vrclient_x64/winIVRDriverManager.c index 2542e09d..060e49f4 100644 --- a/vrclient_x64/winIVRDriverManager.c +++ b/vrclient_x64/winIVRDriverManager.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRDriverManager_IVRDriverManager_001.h" @@ -65,3 +67,29 @@ void destroy_winIVRDriverManager_IVRDriverManager_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRDriverManager_IVRDriverManager_001 *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *linux_side) +{ + winIVRDriverManager_IVRDriverManager_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRDriverManager_IVRDriverManager_001)); + struct thunk *thunks = alloc_thunks(2); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRDriverManager_IVRDriverManager_001_GetDriverCount); + init_thunk(&thunks[1], r, winIVRDriverManager_IVRDriverManager_001_GetDriverName); + for (i = 0; i < 2; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRDriverManager_IVRDriverManager_001_FnTable(void *object) +{ + winIVRDriverManager_IVRDriverManager_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRExtendedDisplay.c b/vrclient_x64/winIVRExtendedDisplay.c index e6c048c0..f856566d 100644 --- a/vrclient_x64/winIVRExtendedDisplay.c +++ b/vrclient_x64/winIVRExtendedDisplay.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRExtendedDisplay_IVRExtendedDisplay_001.h" @@ -73,3 +75,30 @@ void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRExtendedDisplay_IVRExtendedDisplay_001 *create_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *linux_side) +{ + winIVRExtendedDisplay_IVRExtendedDisplay_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRExtendedDisplay_IVRExtendedDisplay_001)); + struct thunk *thunks = alloc_thunks(3); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 3 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRExtendedDisplay_IVRExtendedDisplay_001_GetWindowBounds); + init_thunk(&thunks[1], r, winIVRExtendedDisplay_IVRExtendedDisplay_001_GetEyeOutputViewport); + init_thunk(&thunks[2], r, winIVRExtendedDisplay_IVRExtendedDisplay_001_GetDXGIOutputInfo); + for (i = 0; i < 3; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *object) +{ + winIVRExtendedDisplay_IVRExtendedDisplay_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRNotifications.c b/vrclient_x64/winIVRNotifications.c index 95631024..5ea643b3 100644 --- a/vrclient_x64/winIVRNotifications.c +++ b/vrclient_x64/winIVRNotifications.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRNotifications_IVRNotifications_002.h" @@ -65,6 +67,32 @@ void destroy_winIVRNotifications_IVRNotifications_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRNotifications_IVRNotifications_002 *create_winIVRNotifications_IVRNotifications_002_FnTable(void *linux_side) +{ + winIVRNotifications_IVRNotifications_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRNotifications_IVRNotifications_002)); + struct thunk *thunks = alloc_thunks(2); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRNotifications_IVRNotifications_002_CreateNotification); + init_thunk(&thunks[1], r, winIVRNotifications_IVRNotifications_002_RemoveNotification); + for (i = 0; i < 2; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *object) +{ + winIVRNotifications_IVRNotifications_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRNotifications_IVRNotifications_001.h" typedef struct __winIVRNotifications_IVRNotifications_001 { @@ -122,3 +150,30 @@ void destroy_winIVRNotifications_IVRNotifications_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRNotifications_IVRNotifications_001 *create_winIVRNotifications_IVRNotifications_001_FnTable(void *linux_side) +{ + winIVRNotifications_IVRNotifications_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRNotifications_IVRNotifications_001)); + struct thunk *thunks = alloc_thunks(3); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 3 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRNotifications_IVRNotifications_001_GetErrorString); + init_thunk(&thunks[1], r, winIVRNotifications_IVRNotifications_001_CreateNotification); + init_thunk(&thunks[2], r, winIVRNotifications_IVRNotifications_001_DismissNotification); + for (i = 0; i < 3; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRNotifications_IVRNotifications_001_FnTable(void *object) +{ + winIVRNotifications_IVRNotifications_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVROverlay.c b/vrclient_x64/winIVROverlay.c index a4df787a..2d1290fa 100644 --- a/vrclient_x64/winIVROverlay.c +++ b/vrclient_x64/winIVROverlay.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVROverlay_IVROverlay_018.h" @@ -705,6 +707,112 @@ void destroy_winIVROverlay_IVROverlay_018(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_018 *create_winIVROverlay_IVROverlay_018_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_018 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_018)); + struct thunk *thunks = alloc_thunks(82); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 82 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_018_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_018_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_018_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_018_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_018_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_018_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_018_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_018_SetOverlayName); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_018_GetOverlayImageData); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_018_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_018_SetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_018_GetOverlayRenderingPid); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_018_SetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_018_GetOverlayFlag); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_018_SetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_018_GetOverlayColor); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_018_SetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_018_GetOverlayAlpha); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_018_SetOverlayTexelAspect); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_018_GetOverlayTexelAspect); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_018_SetOverlaySortOrder); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_018_GetOverlaySortOrder); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_018_SetOverlayWidthInMeters); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_018_GetOverlayWidthInMeters); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_018_SetOverlayTextureColorSpace); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_018_GetOverlayTextureColorSpace); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_018_SetOverlayTextureBounds); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_018_GetOverlayTextureBounds); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_018_GetOverlayRenderModel); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_018_SetOverlayRenderModel); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_018_GetOverlayTransformType); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_018_SetOverlayTransformAbsolute); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_018_GetOverlayTransformAbsolute); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_018_GetOverlayTransformOverlayRelative); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_018_SetOverlayTransformOverlayRelative); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_018_ShowOverlay); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_018_HideOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_018_IsOverlayVisible); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_018_PollNextOverlayEvent); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_018_GetOverlayInputMethod); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_018_SetOverlayInputMethod); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_018_GetOverlayMouseScale); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_018_SetOverlayMouseScale); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_018_ComputeOverlayIntersection); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_018_IsHoverTargetOverlay); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_018_GetGamepadFocusOverlay); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_018_SetGamepadFocusOverlay); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_018_SetOverlayNeighbor); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_018_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_018_SetOverlayDualAnalogTransform); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_018_GetOverlayDualAnalogTransform); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_018_SetOverlayTexture); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_018_ClearOverlayTexture); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_018_SetOverlayRaw); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_018_SetOverlayFromFile); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_018_GetOverlayTexture); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_018_ReleaseNativeOverlayHandle); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_018_GetOverlayTextureSize); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_018_CreateDashboardOverlay); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_018_IsDashboardVisible); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_018_IsActiveDashboardOverlay); + init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_018_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_018_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_018_ShowDashboard); + init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_018_GetPrimaryDashboardDevice); + init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_018_ShowKeyboard); + init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_018_ShowKeyboardForOverlay); + init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_018_GetKeyboardText); + init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_018_HideKeyboard); + init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_018_SetKeyboardTransformAbsolute); + init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_018_SetKeyboardPositionForOverlay); + init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_018_SetOverlayIntersectionMask); + init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_018_GetOverlayFlags); + init_thunk(&thunks[80], r, winIVROverlay_IVROverlay_018_ShowMessageOverlay); + init_thunk(&thunks[81], r, winIVROverlay_IVROverlay_018_CloseMessageOverlay); + for (i = 0; i < 82; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_018_FnTable(void *object) +{ + winIVROverlay_IVROverlay_018 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_017.h" typedef struct __winIVROverlay_IVROverlay_017 { @@ -1402,6 +1510,113 @@ void destroy_winIVROverlay_IVROverlay_017(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_017 *create_winIVROverlay_IVROverlay_017_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_017)); + struct thunk *thunks = alloc_thunks(83); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 83 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_017_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_017_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_017_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_017_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_017_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_017_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_017_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_017_SetOverlayName); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_017_GetOverlayImageData); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_017_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_017_SetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_017_GetOverlayRenderingPid); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_017_SetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_017_GetOverlayFlag); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_017_SetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_017_GetOverlayColor); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_017_SetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_017_GetOverlayAlpha); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_017_SetOverlayTexelAspect); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_017_GetOverlayTexelAspect); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_017_SetOverlaySortOrder); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_017_GetOverlaySortOrder); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_017_SetOverlayWidthInMeters); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_017_GetOverlayWidthInMeters); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_017_SetOverlayTextureColorSpace); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_017_GetOverlayTextureColorSpace); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_017_SetOverlayTextureBounds); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_017_GetOverlayTextureBounds); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_017_GetOverlayRenderModel); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_017_SetOverlayRenderModel); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_017_GetOverlayTransformType); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_017_SetOverlayTransformAbsolute); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_017_GetOverlayTransformAbsolute); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_017_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_017_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_017_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_017_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_017_GetOverlayTransformOverlayRelative); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_017_SetOverlayTransformOverlayRelative); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_017_ShowOverlay); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_017_HideOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_017_IsOverlayVisible); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_017_GetTransformForOverlayCoordinates); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_017_PollNextOverlayEvent); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_017_GetOverlayInputMethod); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_017_SetOverlayInputMethod); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_017_GetOverlayMouseScale); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_017_SetOverlayMouseScale); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_017_ComputeOverlayIntersection); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_017_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_017_IsHoverTargetOverlay); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_017_GetGamepadFocusOverlay); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_017_SetGamepadFocusOverlay); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_017_SetOverlayNeighbor); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_017_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_017_SetOverlayDualAnalogTransform); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_017_GetOverlayDualAnalogTransform); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_017_SetOverlayTexture); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_017_ClearOverlayTexture); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_017_SetOverlayRaw); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_017_SetOverlayFromFile); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_017_GetOverlayTexture); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_017_ReleaseNativeOverlayHandle); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_017_GetOverlayTextureSize); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_017_CreateDashboardOverlay); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_017_IsDashboardVisible); + init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_017_IsActiveDashboardOverlay); + init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_017_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_017_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_017_ShowDashboard); + init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_017_GetPrimaryDashboardDevice); + init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_017_ShowKeyboard); + init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_017_ShowKeyboardForOverlay); + init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_017_GetKeyboardText); + init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_017_HideKeyboard); + init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_017_SetKeyboardTransformAbsolute); + init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_017_SetKeyboardPositionForOverlay); + init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_017_SetOverlayIntersectionMask); + init_thunk(&thunks[80], r, winIVROverlay_IVROverlay_017_GetOverlayFlags); + init_thunk(&thunks[81], r, winIVROverlay_IVROverlay_017_ShowMessageOverlay); + init_thunk(&thunks[82], r, winIVROverlay_IVROverlay_017_CloseMessageOverlay); + for (i = 0; i < 83; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_017_FnTable(void *object) +{ + winIVROverlay_IVROverlay_017 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_016.h" typedef struct __winIVROverlay_IVROverlay_016 { @@ -2083,6 +2298,111 @@ void destroy_winIVROverlay_IVROverlay_016(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_016 *create_winIVROverlay_IVROverlay_016_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_016 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_016)); + struct thunk *thunks = alloc_thunks(81); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 81 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_016_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_016_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_016_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_016_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_016_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_016_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_016_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_016_SetOverlayName); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_016_GetOverlayImageData); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_016_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_016_SetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_016_GetOverlayRenderingPid); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_016_SetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_016_GetOverlayFlag); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_016_SetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_016_GetOverlayColor); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_016_SetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_016_GetOverlayAlpha); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_016_SetOverlayTexelAspect); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_016_GetOverlayTexelAspect); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_016_SetOverlaySortOrder); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_016_GetOverlaySortOrder); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_016_SetOverlayWidthInMeters); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_016_GetOverlayWidthInMeters); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_016_SetOverlayTextureColorSpace); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_016_GetOverlayTextureColorSpace); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_016_SetOverlayTextureBounds); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_016_GetOverlayTextureBounds); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_016_GetOverlayRenderModel); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_016_SetOverlayRenderModel); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_016_GetOverlayTransformType); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_016_SetOverlayTransformAbsolute); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_016_GetOverlayTransformAbsolute); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_016_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_016_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_016_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_016_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_016_GetOverlayTransformOverlayRelative); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_016_SetOverlayTransformOverlayRelative); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_016_ShowOverlay); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_016_HideOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_016_IsOverlayVisible); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_016_GetTransformForOverlayCoordinates); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_016_PollNextOverlayEvent); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_016_GetOverlayInputMethod); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_016_SetOverlayInputMethod); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_016_GetOverlayMouseScale); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_016_SetOverlayMouseScale); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_016_ComputeOverlayIntersection); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_016_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_016_IsHoverTargetOverlay); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_016_GetGamepadFocusOverlay); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_016_SetGamepadFocusOverlay); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_016_SetOverlayNeighbor); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_016_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_016_SetOverlayTexture); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_016_ClearOverlayTexture); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_016_SetOverlayRaw); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_016_SetOverlayFromFile); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_016_GetOverlayTexture); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_016_ReleaseNativeOverlayHandle); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_016_GetOverlayTextureSize); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_016_CreateDashboardOverlay); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_016_IsDashboardVisible); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_016_IsActiveDashboardOverlay); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_016_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_016_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_016_ShowDashboard); + init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_016_GetPrimaryDashboardDevice); + init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_016_ShowKeyboard); + init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_016_ShowKeyboardForOverlay); + init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_016_GetKeyboardText); + init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_016_HideKeyboard); + init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_016_SetKeyboardTransformAbsolute); + init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_016_SetKeyboardPositionForOverlay); + init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_016_SetOverlayIntersectionMask); + init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_016_GetOverlayFlags); + init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_016_ShowMessageOverlay); + init_thunk(&thunks[80], r, winIVROverlay_IVROverlay_016_CloseMessageOverlay); + for (i = 0; i < 81; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_016_FnTable(void *object) +{ + winIVROverlay_IVROverlay_016 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_014.h" typedef struct __winIVROverlay_IVROverlay_014 { @@ -2716,6 +3036,105 @@ void destroy_winIVROverlay_IVROverlay_014(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_014 *create_winIVROverlay_IVROverlay_014_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_014 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_014)); + struct thunk *thunks = alloc_thunks(75); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 75 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_014_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_014_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_014_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_014_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_014_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_014_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_014_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_014_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_014_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_014_SetOverlayRenderingPid); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_014_GetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_014_SetOverlayFlag); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_014_GetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_014_SetOverlayColor); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_014_GetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_014_SetOverlayAlpha); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_014_GetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_014_SetOverlayTexelAspect); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_014_GetOverlayTexelAspect); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_014_SetOverlaySortOrder); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_014_GetOverlaySortOrder); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_014_SetOverlayWidthInMeters); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_014_GetOverlayWidthInMeters); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_014_SetOverlayTextureColorSpace); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_014_GetOverlayTextureColorSpace); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_014_SetOverlayTextureBounds); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_014_GetOverlayTextureBounds); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_014_GetOverlayTransformType); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_014_SetOverlayTransformAbsolute); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_014_GetOverlayTransformAbsolute); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_014_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_014_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_014_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_014_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_014_ShowOverlay); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_014_HideOverlay); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_014_IsOverlayVisible); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_014_GetTransformForOverlayCoordinates); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_014_PollNextOverlayEvent); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_014_GetOverlayInputMethod); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_014_SetOverlayInputMethod); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_014_GetOverlayMouseScale); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_014_SetOverlayMouseScale); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_014_ComputeOverlayIntersection); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_014_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_014_IsHoverTargetOverlay); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_014_GetGamepadFocusOverlay); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_014_SetGamepadFocusOverlay); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_014_SetOverlayNeighbor); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_014_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_014_SetOverlayTexture); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_014_ClearOverlayTexture); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_014_SetOverlayRaw); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_014_SetOverlayFromFile); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_014_GetOverlayTexture); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_014_ReleaseNativeOverlayHandle); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_014_GetOverlayTextureSize); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_014_CreateDashboardOverlay); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_014_IsDashboardVisible); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_014_IsActiveDashboardOverlay); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_014_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_014_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_014_ShowDashboard); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_014_GetPrimaryDashboardDevice); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_014_ShowKeyboard); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_014_ShowKeyboardForOverlay); + init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_014_GetKeyboardText); + init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_014_HideKeyboard); + init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_014_SetKeyboardTransformAbsolute); + init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_014_SetKeyboardPositionForOverlay); + init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_014_SetOverlayIntersectionMask); + init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_014_GetOverlayFlags); + init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_014_ShowMessageOverlay); + for (i = 0; i < 75; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_014_FnTable(void *object) +{ + winIVROverlay_IVROverlay_014 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_013.h" typedef struct __winIVROverlay_IVROverlay_013 { @@ -3333,6 +3752,103 @@ void destroy_winIVROverlay_IVROverlay_013(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_013 *create_winIVROverlay_IVROverlay_013_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_013 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_013)); + struct thunk *thunks = alloc_thunks(73); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 73 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_013_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_013_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_013_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_013_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_013_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_013_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_013_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_013_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_013_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_013_SetOverlayRenderingPid); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_013_GetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_013_SetOverlayFlag); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_013_GetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_013_SetOverlayColor); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_013_GetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_013_SetOverlayAlpha); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_013_GetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_013_SetOverlayTexelAspect); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_013_GetOverlayTexelAspect); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_013_SetOverlaySortOrder); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_013_GetOverlaySortOrder); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_013_SetOverlayWidthInMeters); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_013_GetOverlayWidthInMeters); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_013_SetOverlayTextureColorSpace); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_013_GetOverlayTextureColorSpace); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_013_SetOverlayTextureBounds); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_013_GetOverlayTextureBounds); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_013_GetOverlayTransformType); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_013_SetOverlayTransformAbsolute); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_013_GetOverlayTransformAbsolute); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_013_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_013_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_013_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_013_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_013_ShowOverlay); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_013_HideOverlay); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_013_IsOverlayVisible); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_013_GetTransformForOverlayCoordinates); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_013_PollNextOverlayEvent); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_013_GetOverlayInputMethod); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_013_SetOverlayInputMethod); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_013_GetOverlayMouseScale); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_013_SetOverlayMouseScale); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_013_ComputeOverlayIntersection); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_013_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_013_IsHoverTargetOverlay); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_013_GetGamepadFocusOverlay); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_013_SetGamepadFocusOverlay); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_013_SetOverlayNeighbor); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_013_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_013_SetOverlayTexture); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_013_ClearOverlayTexture); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_013_SetOverlayRaw); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_013_SetOverlayFromFile); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_013_GetOverlayTexture); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_013_ReleaseNativeOverlayHandle); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_013_GetOverlayTextureSize); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_013_CreateDashboardOverlay); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_013_IsDashboardVisible); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_013_IsActiveDashboardOverlay); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_013_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_013_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_013_ShowDashboard); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_013_GetPrimaryDashboardDevice); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_013_ShowKeyboard); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_013_ShowKeyboardForOverlay); + init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_013_GetKeyboardText); + init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_013_HideKeyboard); + init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_013_SetKeyboardTransformAbsolute); + init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_013_SetKeyboardPositionForOverlay); + init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_013_SetOverlayIntersectionMask); + for (i = 0; i < 73; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_013_FnTable(void *object) +{ + winIVROverlay_IVROverlay_013 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_012.h" typedef struct __winIVROverlay_IVROverlay_012 { @@ -3910,6 +4426,98 @@ void destroy_winIVROverlay_IVROverlay_012(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_012 *create_winIVROverlay_IVROverlay_012_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_012 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_012)); + struct thunk *thunks = alloc_thunks(68); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 68 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_012_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_012_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_012_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_012_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_012_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_012_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_012_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_012_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_012_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_012_SetOverlayRenderingPid); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_012_GetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_012_SetOverlayFlag); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_012_GetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_012_SetOverlayColor); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_012_GetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_012_SetOverlayAlpha); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_012_GetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_012_SetOverlayWidthInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_012_GetOverlayWidthInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_012_SetOverlayTextureColorSpace); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_012_GetOverlayTextureColorSpace); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_012_SetOverlayTextureBounds); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_012_GetOverlayTextureBounds); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_012_GetOverlayTransformType); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_012_SetOverlayTransformAbsolute); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_012_GetOverlayTransformAbsolute); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_012_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_012_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_012_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_012_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_012_ShowOverlay); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_012_HideOverlay); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_012_IsOverlayVisible); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_012_GetTransformForOverlayCoordinates); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_012_PollNextOverlayEvent); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_012_GetOverlayInputMethod); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_012_SetOverlayInputMethod); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_012_GetOverlayMouseScale); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_012_SetOverlayMouseScale); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_012_ComputeOverlayIntersection); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_012_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_012_IsHoverTargetOverlay); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_012_GetGamepadFocusOverlay); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_012_SetGamepadFocusOverlay); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_012_SetOverlayNeighbor); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_012_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_012_SetOverlayTexture); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_012_ClearOverlayTexture); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_012_SetOverlayRaw); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_012_SetOverlayFromFile); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_012_GetOverlayTexture); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_012_ReleaseNativeOverlayHandle); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_012_GetOverlayTextureSize); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_012_CreateDashboardOverlay); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_012_IsDashboardVisible); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_012_IsActiveDashboardOverlay); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_012_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_012_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_012_ShowDashboard); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_012_GetPrimaryDashboardDevice); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_012_ShowKeyboard); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_012_ShowKeyboardForOverlay); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_012_GetKeyboardText); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_012_HideKeyboard); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_012_SetKeyboardTransformAbsolute); + init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_012_SetKeyboardPositionForOverlay); + for (i = 0; i < 68; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_012_FnTable(void *object) +{ + winIVROverlay_IVROverlay_012 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_011.h" typedef struct __winIVROverlay_IVROverlay_011 { @@ -4479,6 +5087,97 @@ void destroy_winIVROverlay_IVROverlay_011(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_011 *create_winIVROverlay_IVROverlay_011_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_011 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_011)); + struct thunk *thunks = alloc_thunks(67); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 67 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_011_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_011_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_011_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_011_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_011_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_011_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_011_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_011_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_011_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_011_SetOverlayRenderingPid); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_011_GetOverlayRenderingPid); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_011_SetOverlayFlag); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_011_GetOverlayFlag); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_011_SetOverlayColor); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_011_GetOverlayColor); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_011_SetOverlayAlpha); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_011_GetOverlayAlpha); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_011_SetOverlayWidthInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_011_GetOverlayWidthInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_011_SetOverlayTextureColorSpace); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_011_GetOverlayTextureColorSpace); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_011_SetOverlayTextureBounds); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_011_GetOverlayTextureBounds); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_011_GetOverlayTransformType); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_011_SetOverlayTransformAbsolute); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_011_GetOverlayTransformAbsolute); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_011_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_011_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_011_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_011_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_011_ShowOverlay); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_011_HideOverlay); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_011_IsOverlayVisible); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_011_GetTransformForOverlayCoordinates); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_011_PollNextOverlayEvent); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_011_GetOverlayInputMethod); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_011_SetOverlayInputMethod); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_011_GetOverlayMouseScale); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_011_SetOverlayMouseScale); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_011_ComputeOverlayIntersection); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_011_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_011_IsHoverTargetOverlay); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_011_GetGamepadFocusOverlay); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_011_SetGamepadFocusOverlay); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_011_SetOverlayNeighbor); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_011_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_011_SetOverlayTexture); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_011_ClearOverlayTexture); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_011_SetOverlayRaw); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_011_SetOverlayFromFile); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_011_GetOverlayTexture); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_011_ReleaseNativeOverlayHandle); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_011_CreateDashboardOverlay); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_011_IsDashboardVisible); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_011_IsActiveDashboardOverlay); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_011_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_011_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_011_ShowDashboard); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_011_GetPrimaryDashboardDevice); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_011_ShowKeyboard); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_011_ShowKeyboardForOverlay); + init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_011_GetKeyboardText); + init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_011_HideKeyboard); + init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_011_SetKeyboardTransformAbsolute); + init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_011_SetKeyboardPositionForOverlay); + for (i = 0; i < 67; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_011_FnTable(void *object) +{ + winIVROverlay_IVROverlay_011 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_010.h" typedef struct __winIVROverlay_IVROverlay_010 { @@ -5016,6 +5715,93 @@ void destroy_winIVROverlay_IVROverlay_010(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_010 *create_winIVROverlay_IVROverlay_010_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_010 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_010)); + struct thunk *thunks = alloc_thunks(63); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 63 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_010_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_010_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_010_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_010_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_010_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_010_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_010_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_010_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_010_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_010_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_010_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_010_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_010_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_010_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_010_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_010_SetOverlayWidthInMeters); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_010_GetOverlayWidthInMeters); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_010_SetOverlayTextureColorSpace); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_010_GetOverlayTextureColorSpace); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_010_SetOverlayTextureBounds); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_010_GetOverlayTextureBounds); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_010_GetOverlayTransformType); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_010_SetOverlayTransformAbsolute); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_010_GetOverlayTransformAbsolute); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_010_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_010_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_010_SetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_010_GetOverlayTransformTrackedDeviceComponent); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_010_ShowOverlay); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_010_HideOverlay); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_010_IsOverlayVisible); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_010_GetTransformForOverlayCoordinates); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_010_PollNextOverlayEvent); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_010_GetOverlayInputMethod); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_010_SetOverlayInputMethod); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_010_GetOverlayMouseScale); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_010_SetOverlayMouseScale); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_010_ComputeOverlayIntersection); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_010_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_010_IsHoverTargetOverlay); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_010_GetGamepadFocusOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_010_SetGamepadFocusOverlay); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_010_SetOverlayNeighbor); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_010_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_010_SetOverlayTexture); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_010_ClearOverlayTexture); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_010_SetOverlayRaw); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_010_SetOverlayFromFile); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_010_CreateDashboardOverlay); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_010_IsDashboardVisible); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_010_IsActiveDashboardOverlay); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_010_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_010_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_010_ShowDashboard); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_010_GetPrimaryDashboardDevice); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_010_ShowKeyboard); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_010_ShowKeyboardForOverlay); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_010_GetKeyboardText); + init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_010_HideKeyboard); + init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_010_SetKeyboardTransformAbsolute); + init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_010_SetKeyboardPositionForOverlay); + for (i = 0; i < 63; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_010_FnTable(void *object) +{ + winIVROverlay_IVROverlay_010 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_008.h" typedef struct __winIVROverlay_IVROverlay_008 { @@ -5529,6 +6315,90 @@ void destroy_winIVROverlay_IVROverlay_008(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_008 *create_winIVROverlay_IVROverlay_008_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_008 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_008)); + struct thunk *thunks = alloc_thunks(60); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 60 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_008_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_008_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_008_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_008_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_008_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_008_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_008_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_008_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_008_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_008_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_008_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_008_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_008_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_008_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_008_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_008_SetOverlayWidthInMeters); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_008_GetOverlayWidthInMeters); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_008_SetOverlayTextureColorSpace); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_008_GetOverlayTextureColorSpace); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_008_SetOverlayTextureBounds); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_008_GetOverlayTextureBounds); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_008_GetOverlayTransformType); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_008_SetOverlayTransformAbsolute); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_008_GetOverlayTransformAbsolute); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_008_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_008_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_008_ShowOverlay); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_008_HideOverlay); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_008_IsOverlayVisible); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_008_GetTransformForOverlayCoordinates); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_008_PollNextOverlayEvent); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_008_GetOverlayInputMethod); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_008_SetOverlayInputMethod); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_008_GetOverlayMouseScale); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_008_SetOverlayMouseScale); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_008_ComputeOverlayIntersection); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_008_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_008_IsHoverTargetOverlay); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_008_GetGamepadFocusOverlay); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_008_SetGamepadFocusOverlay); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_008_SetOverlayNeighbor); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_008_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_008_SetOverlayTexture); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_008_ClearOverlayTexture); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_008_SetOverlayRaw); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_008_SetOverlayFromFile); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_008_CreateDashboardOverlay); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_008_IsDashboardVisible); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_008_IsActiveDashboardOverlay); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_008_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_008_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_008_ShowDashboard); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_008_ShowKeyboard); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_008_ShowKeyboardForOverlay); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_008_GetKeyboardText); + init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_008_HideKeyboard); + init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_008_SetKeyboardTransformAbsolute); + init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_008_SetKeyboardPositionForOverlay); + for (i = 0; i < 60; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_008_FnTable(void *object) +{ + winIVROverlay_IVROverlay_008 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_007.h" typedef struct __winIVROverlay_IVROverlay_007 { @@ -6018,6 +6888,87 @@ void destroy_winIVROverlay_IVROverlay_007(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_007 *create_winIVROverlay_IVROverlay_007_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_007)); + struct thunk *thunks = alloc_thunks(57); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 57 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_007_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_007_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_007_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_007_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_007_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_007_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_007_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_007_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_007_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_007_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_007_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_007_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_007_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_007_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_007_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_007_SetOverlayWidthInMeters); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_007_GetOverlayWidthInMeters); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_007_SetOverlayTextureColorSpace); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_007_GetOverlayTextureColorSpace); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_007_SetOverlayTextureBounds); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_007_GetOverlayTextureBounds); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_007_GetOverlayTransformType); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_007_SetOverlayTransformAbsolute); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_007_GetOverlayTransformAbsolute); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_007_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_007_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_007_ShowOverlay); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_007_HideOverlay); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_007_IsOverlayVisible); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_007_PollNextOverlayEvent); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_007_GetOverlayInputMethod); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_007_SetOverlayInputMethod); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_007_GetOverlayMouseScale); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_007_SetOverlayMouseScale); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_007_ComputeOverlayIntersection); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_007_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_007_IsHoverTargetOverlay); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_007_GetGamepadFocusOverlay); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_007_SetGamepadFocusOverlay); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_007_SetOverlayNeighbor); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_007_MoveGamepadFocusToNeighbor); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_007_SetOverlayTexture); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_007_ClearOverlayTexture); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_007_SetOverlayRaw); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_007_SetOverlayFromFile); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_007_CreateDashboardOverlay); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_007_IsDashboardVisible); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_007_IsActiveDashboardOverlay); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_007_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_007_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_007_ShowDashboard); + init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_007_ShowKeyboard); + init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_007_ShowKeyboardForOverlay); + init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_007_GetKeyboardText); + init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_007_HideKeyboard); + for (i = 0; i < 57; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_007_FnTable(void *object) +{ + winIVROverlay_IVROverlay_007 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_005.h" typedef struct __winIVROverlay_IVROverlay_005 { @@ -6467,6 +7418,82 @@ void destroy_winIVROverlay_IVROverlay_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_005 *create_winIVROverlay_IVROverlay_005_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_005)); + struct thunk *thunks = alloc_thunks(52); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 52 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_005_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_005_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_005_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_005_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_005_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_005_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_005_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_005_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_005_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_005_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_005_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_005_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_005_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_005_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_005_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_005_SetOverlayGamma); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_005_GetOverlayGamma); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_005_SetOverlayWidthInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_005_GetOverlayWidthInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_005_SetOverlayTextureBounds); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_005_GetOverlayTextureBounds); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_005_GetOverlayTransformType); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_005_SetOverlayTransformAbsolute); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_005_GetOverlayTransformAbsolute); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_005_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_005_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_005_ShowOverlay); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_005_HideOverlay); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_005_IsOverlayVisible); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_005_PollNextOverlayEvent); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_005_GetOverlayInputMethod); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_005_SetOverlayInputMethod); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_005_GetOverlayMouseScale); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_005_SetOverlayMouseScale); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_005_ComputeOverlayIntersection); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_005_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_005_IsFocusOverlay); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_005_SetOverlayTexture); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_005_ClearOverlayTexture); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_005_SetOverlayRaw); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_005_SetOverlayFromFile); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_005_CreateDashboardOverlay); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_005_IsDashboardVisible); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_005_IsActiveDashboardOverlay); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_005_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_005_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_005_ShowDashboard); + init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_005_ShowKeyboard); + init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_005_GetKeyboardText); + init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_005_HideKeyboard); + for (i = 0; i < 52; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_005_FnTable(void *object) +{ + winIVROverlay_IVROverlay_005 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_004.h" typedef struct __winIVROverlay_IVROverlay_004 { @@ -6884,6 +7911,78 @@ void destroy_winIVROverlay_IVROverlay_004(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_004 *create_winIVROverlay_IVROverlay_004_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_004)); + struct thunk *thunks = alloc_thunks(48); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 48 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_004_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_004_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_004_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_004_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_004_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_004_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_004_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_004_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_004_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_004_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_004_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_004_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_004_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_004_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_004_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_004_SetOverlayGamma); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_004_GetOverlayGamma); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_004_SetOverlayWidthInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_004_GetOverlayWidthInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_004_SetOverlayTextureBounds); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_004_GetOverlayTextureBounds); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_004_GetOverlayTransformType); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_004_SetOverlayTransformAbsolute); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_004_GetOverlayTransformAbsolute); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_004_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_004_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_004_ShowOverlay); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_004_HideOverlay); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_004_IsOverlayVisible); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_004_PollNextOverlayEvent); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_004_GetOverlayInputMethod); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_004_SetOverlayInputMethod); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_004_GetOverlayMouseScale); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_004_SetOverlayMouseScale); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_004_ComputeOverlayIntersection); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_004_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_004_SetOverlayTexture); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_004_ClearOverlayTexture); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_004_SetOverlayRaw); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_004_SetOverlayFromFile); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_004_CreateDashboardOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_004_IsDashboardVisible); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_004_IsActiveDashboardOverlay); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_004_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_004_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_004_ShowDashboard); + for (i = 0; i < 48; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_004_FnTable(void *object) +{ + winIVROverlay_IVROverlay_004 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_003.h" typedef struct __winIVROverlay_IVROverlay_003 { @@ -7285,6 +8384,76 @@ void destroy_winIVROverlay_IVROverlay_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_003 *create_winIVROverlay_IVROverlay_003_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_003)); + struct thunk *thunks = alloc_thunks(46); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 46 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_003_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_003_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_003_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_003_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_003_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_003_GetOverlayKey); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_003_GetOverlayName); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_003_GetOverlayImageData); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_003_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_003_SetOverlayFlag); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_003_GetOverlayFlag); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_003_SetOverlayColor); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_003_GetOverlayColor); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_003_SetOverlayAlpha); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_003_GetOverlayAlpha); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_003_SetOverlayGamma); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_003_GetOverlayGamma); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_003_SetOverlayWidthInMeters); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_003_GetOverlayWidthInMeters); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_003_SetOverlayTextureBounds); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_003_GetOverlayTextureBounds); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_003_GetOverlayTransformType); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_003_SetOverlayTransformAbsolute); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_003_GetOverlayTransformAbsolute); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_003_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_003_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_003_ShowOverlay); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_003_HideOverlay); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_003_IsOverlayVisible); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_003_PollNextOverlayEvent); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_003_GetOverlayInputMethod); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_003_SetOverlayInputMethod); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_003_GetOverlayMouseScale); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_003_SetOverlayMouseScale); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_003_ComputeOverlayIntersection); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_003_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_003_SetOverlayTexture); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_003_ClearOverlayTexture); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_003_SetOverlayRaw); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_003_SetOverlayFromFile); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_003_CreateDashboardOverlay); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_003_IsDashboardVisible); + init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_003_IsActiveDashboardOverlay); + init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_003_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_003_GetDashboardOverlaySceneProcess); + init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_003_ShowDashboard); + for (i = 0; i < 46; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_003_FnTable(void *object) +{ + winIVROverlay_IVROverlay_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_002.h" typedef struct __winIVROverlay_IVROverlay_002 { @@ -7654,6 +8823,72 @@ void destroy_winIVROverlay_IVROverlay_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_002 *create_winIVROverlay_IVROverlay_002_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_002)); + struct thunk *thunks = alloc_thunks(42); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 42 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_002_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_002_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_002_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_002_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_002_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_002_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_002_SetOverlayFlag); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_002_GetOverlayFlag); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_002_SetOverlayColor); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_002_GetOverlayColor); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_002_SetOverlayAlpha); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_002_GetOverlayAlpha); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_002_SetOverlayGamma); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_002_GetOverlayGamma); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_002_SetOverlayWidthInMeters); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_002_GetOverlayWidthInMeters); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_002_SetOverlayTextureBounds); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_002_GetOverlayTextureBounds); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_002_GetOverlayTransformType); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_002_SetOverlayTransformAbsolute); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_002_GetOverlayTransformAbsolute); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_002_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_002_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_002_ShowOverlay); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_002_HideOverlay); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_002_IsOverlayVisible); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_002_PollNextOverlayEvent); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_002_GetOverlayInputMethod); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_002_SetOverlayInputMethod); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_002_GetOverlayMouseScale); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_002_SetOverlayMouseScale); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_002_ComputeOverlayIntersection); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_002_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_002_SetOverlayTexture); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_002_ClearOverlayTexture); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_002_SetOverlayRaw); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_002_SetOverlayFromFile); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_002_CreateDashboardOverlay); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_002_IsDashboardVisible); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_002_IsActiveDashboardOverlay); + init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_002_SetDashboardOverlaySceneProcess); + init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_002_GetDashboardOverlaySceneProcess); + for (i = 0; i < 42; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_002_FnTable(void *object) +{ + winIVROverlay_IVROverlay_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVROverlay_IVROverlay_001.h" typedef struct __winIVROverlay_IVROverlay_001 { @@ -8007,3 +9242,67 @@ void destroy_winIVROverlay_IVROverlay_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVROverlay_IVROverlay_001 *create_winIVROverlay_IVROverlay_001_FnTable(void *linux_side) +{ + winIVROverlay_IVROverlay_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_001)); + struct thunk *thunks = alloc_thunks(40); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 40 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_001_FindOverlay); + init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_001_CreateOverlay); + init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_001_DestroyOverlay); + init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_001_SetHighQualityOverlay); + init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_001_GetHighQualityOverlay); + init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_001_GetOverlayErrorNameFromEnum); + init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_001_SetOverlayFlag); + init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_001_GetOverlayFlag); + init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_001_SetOverlayAlpha); + init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_001_GetOverlayAlpha); + init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_001_SetOverlayGamma); + init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_001_GetOverlayGamma); + init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_001_SetOverlayWidthInMeters); + init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_001_GetOverlayWidthInMeters); + init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_001_SetOverlayTextureBounds); + init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_001_GetOverlayTextureBounds); + init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_001_GetOverlayTransformType); + init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_001_SetOverlayTransformAbsolute); + init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_001_GetOverlayTransformAbsolute); + init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_001_SetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_001_GetOverlayTransformTrackedDeviceRelative); + init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_001_GetOverlayVisibility); + init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_001_SetOverlayVisibility); + init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_001_ShowOverlay); + init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_001_HideOverlay); + init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_001_IsOverlayVisible); + init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_001_PollNextOverlayEvent); + init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_001_GetOverlayInputMethod); + init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_001_SetOverlayInputMethod); + init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_001_GetOverlayMouseScale); + init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_001_SetOverlayMouseScale); + init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_001_ComputeOverlayIntersection); + init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_001_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_001_SetOverlayTexture); + init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_001_SetOverlayRaw); + init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_001_SetOverlayFromFile); + init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_001_IsSystemOverlayVisible); + init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_001_IsActiveSystemOverlay); + init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_001_SetSystemOverlaySceneProcess); + init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_001_GetSystemOverlaySceneProcess); + for (i = 0; i < 40; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVROverlay_IVROverlay_001_FnTable(void *object) +{ + winIVROverlay_IVROverlay_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRRenderModels.c b/vrclient_x64/winIVRRenderModels.c index 26f9297f..2d1b0f15 100644 --- a/vrclient_x64/winIVRRenderModels.c +++ b/vrclient_x64/winIVRRenderModels.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRRenderModels_IVRRenderModels_005.h" @@ -193,6 +195,48 @@ void destroy_winIVRRenderModels_IVRRenderModels_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRRenderModels_IVRRenderModels_005 *create_winIVRRenderModels_IVRRenderModels_005_FnTable(void *linux_side) +{ + winIVRRenderModels_IVRRenderModels_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_005)); + struct thunk *thunks = alloc_thunks(18); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 18 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async); + init_thunk(&thunks[1], r, winIVRRenderModels_IVRRenderModels_005_FreeRenderModel); + init_thunk(&thunks[2], r, winIVRRenderModels_IVRRenderModels_005_LoadTexture_Async); + init_thunk(&thunks[3], r, winIVRRenderModels_IVRRenderModels_005_FreeTexture); + init_thunk(&thunks[4], r, winIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async); + init_thunk(&thunks[5], r, winIVRRenderModels_IVRRenderModels_005_LoadIntoTextureD3D11_Async); + init_thunk(&thunks[6], r, winIVRRenderModels_IVRRenderModels_005_FreeTextureD3D11); + init_thunk(&thunks[7], r, winIVRRenderModels_IVRRenderModels_005_GetRenderModelName); + init_thunk(&thunks[8], r, winIVRRenderModels_IVRRenderModels_005_GetRenderModelCount); + init_thunk(&thunks[9], r, winIVRRenderModels_IVRRenderModels_005_GetComponentCount); + init_thunk(&thunks[10], r, winIVRRenderModels_IVRRenderModels_005_GetComponentName); + init_thunk(&thunks[11], r, winIVRRenderModels_IVRRenderModels_005_GetComponentButtonMask); + init_thunk(&thunks[12], r, winIVRRenderModels_IVRRenderModels_005_GetComponentRenderModelName); + init_thunk(&thunks[13], r, winIVRRenderModels_IVRRenderModels_005_GetComponentState); + init_thunk(&thunks[14], r, winIVRRenderModels_IVRRenderModels_005_RenderModelHasComponent); + init_thunk(&thunks[15], r, winIVRRenderModels_IVRRenderModels_005_GetRenderModelThumbnailURL); + init_thunk(&thunks[16], r, winIVRRenderModels_IVRRenderModels_005_GetRenderModelOriginalPath); + init_thunk(&thunks[17], r, winIVRRenderModels_IVRRenderModels_005_GetRenderModelErrorNameFromEnum); + for (i = 0; i < 18; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRRenderModels_IVRRenderModels_005_FnTable(void *object) +{ + winIVRRenderModels_IVRRenderModels_005 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRRenderModels_IVRRenderModels_004.h" typedef struct __winIVRRenderModels_IVRRenderModels_004 { @@ -338,6 +382,44 @@ void destroy_winIVRRenderModels_IVRRenderModels_004(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRRenderModels_IVRRenderModels_004 *create_winIVRRenderModels_IVRRenderModels_004_FnTable(void *linux_side) +{ + winIVRRenderModels_IVRRenderModels_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_004)); + struct thunk *thunks = alloc_thunks(14); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 14 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRRenderModels_IVRRenderModels_004_LoadRenderModel_Async); + init_thunk(&thunks[1], r, winIVRRenderModels_IVRRenderModels_004_FreeRenderModel); + init_thunk(&thunks[2], r, winIVRRenderModels_IVRRenderModels_004_LoadTexture_Async); + init_thunk(&thunks[3], r, winIVRRenderModels_IVRRenderModels_004_FreeTexture); + init_thunk(&thunks[4], r, winIVRRenderModels_IVRRenderModels_004_LoadTextureD3D11_Async); + init_thunk(&thunks[5], r, winIVRRenderModels_IVRRenderModels_004_FreeTextureD3D11); + init_thunk(&thunks[6], r, winIVRRenderModels_IVRRenderModels_004_GetRenderModelName); + init_thunk(&thunks[7], r, winIVRRenderModels_IVRRenderModels_004_GetRenderModelCount); + init_thunk(&thunks[8], r, winIVRRenderModels_IVRRenderModels_004_GetComponentCount); + init_thunk(&thunks[9], r, winIVRRenderModels_IVRRenderModels_004_GetComponentName); + init_thunk(&thunks[10], r, winIVRRenderModels_IVRRenderModels_004_GetComponentButtonMask); + init_thunk(&thunks[11], r, winIVRRenderModels_IVRRenderModels_004_GetComponentRenderModelName); + init_thunk(&thunks[12], r, winIVRRenderModels_IVRRenderModels_004_GetComponentState); + init_thunk(&thunks[13], r, winIVRRenderModels_IVRRenderModels_004_RenderModelHasComponent); + for (i = 0; i < 14; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRRenderModels_IVRRenderModels_004_FnTable(void *object) +{ + winIVRRenderModels_IVRRenderModels_004 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRRenderModels_IVRRenderModels_002.h" typedef struct __winIVRRenderModels_IVRRenderModels_002 { @@ -467,6 +549,42 @@ void destroy_winIVRRenderModels_IVRRenderModels_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRRenderModels_IVRRenderModels_002 *create_winIVRRenderModels_IVRRenderModels_002_FnTable(void *linux_side) +{ + winIVRRenderModels_IVRRenderModels_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_002)); + struct thunk *thunks = alloc_thunks(12); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRRenderModels_IVRRenderModels_002_LoadRenderModel); + init_thunk(&thunks[1], r, winIVRRenderModels_IVRRenderModels_002_FreeRenderModel); + init_thunk(&thunks[2], r, winIVRRenderModels_IVRRenderModels_002_LoadTexture); + init_thunk(&thunks[3], r, winIVRRenderModels_IVRRenderModels_002_FreeTexture); + init_thunk(&thunks[4], r, winIVRRenderModels_IVRRenderModels_002_GetRenderModelName); + init_thunk(&thunks[5], r, winIVRRenderModels_IVRRenderModels_002_GetRenderModelCount); + init_thunk(&thunks[6], r, winIVRRenderModels_IVRRenderModels_002_GetComponentCount); + init_thunk(&thunks[7], r, winIVRRenderModels_IVRRenderModels_002_GetComponentName); + init_thunk(&thunks[8], r, winIVRRenderModels_IVRRenderModels_002_GetComponentButtonMask); + init_thunk(&thunks[9], r, winIVRRenderModels_IVRRenderModels_002_GetComponentRenderModelName); + init_thunk(&thunks[10], r, winIVRRenderModels_IVRRenderModels_002_GetComponentState); + init_thunk(&thunks[11], r, winIVRRenderModels_IVRRenderModels_002_RenderModelHasComponent); + for (i = 0; i < 12; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRRenderModels_IVRRenderModels_002_FnTable(void *object) +{ + winIVRRenderModels_IVRRenderModels_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRRenderModels_IVRRenderModels_001.h" typedef struct __winIVRRenderModels_IVRRenderModels_001 { @@ -532,3 +650,31 @@ void destroy_winIVRRenderModels_IVRRenderModels_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRRenderModels_IVRRenderModels_001 *create_winIVRRenderModels_IVRRenderModels_001_FnTable(void *linux_side) +{ + winIVRRenderModels_IVRRenderModels_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_001)); + struct thunk *thunks = alloc_thunks(4); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 4 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRRenderModels_IVRRenderModels_001_LoadRenderModel); + init_thunk(&thunks[1], r, winIVRRenderModels_IVRRenderModels_001_FreeRenderModel); + init_thunk(&thunks[2], r, winIVRRenderModels_IVRRenderModels_001_GetRenderModelName); + init_thunk(&thunks[3], r, winIVRRenderModels_IVRRenderModels_001_GetRenderModelCount); + for (i = 0; i < 4; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRRenderModels_IVRRenderModels_001_FnTable(void *object) +{ + winIVRRenderModels_IVRRenderModels_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRResources.c b/vrclient_x64/winIVRResources.c index 99f53a94..333007ac 100644 --- a/vrclient_x64/winIVRResources.c +++ b/vrclient_x64/winIVRResources.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRResources_IVRResources_001.h" @@ -65,3 +67,29 @@ void destroy_winIVRResources_IVRResources_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRResources_IVRResources_001 *create_winIVRResources_IVRResources_001_FnTable(void *linux_side) +{ + winIVRResources_IVRResources_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRResources_IVRResources_001)); + struct thunk *thunks = alloc_thunks(2); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRResources_IVRResources_001_LoadSharedResource); + init_thunk(&thunks[1], r, winIVRResources_IVRResources_001_GetResourceFullPath); + for (i = 0; i < 2; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRResources_IVRResources_001_FnTable(void *object) +{ + winIVRResources_IVRResources_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRScreenshots.c b/vrclient_x64/winIVRScreenshots.c index 33330b39..33d59860 100644 --- a/vrclient_x64/winIVRScreenshots.c +++ b/vrclient_x64/winIVRScreenshots.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRScreenshots_IVRScreenshots_001.h" @@ -105,3 +107,34 @@ void destroy_winIVRScreenshots_IVRScreenshots_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRScreenshots_IVRScreenshots_001 *create_winIVRScreenshots_IVRScreenshots_001_FnTable(void *linux_side) +{ + winIVRScreenshots_IVRScreenshots_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRScreenshots_IVRScreenshots_001)); + struct thunk *thunks = alloc_thunks(7); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 7 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRScreenshots_IVRScreenshots_001_RequestScreenshot); + init_thunk(&thunks[1], r, winIVRScreenshots_IVRScreenshots_001_HookScreenshot); + init_thunk(&thunks[2], r, winIVRScreenshots_IVRScreenshots_001_GetScreenshotPropertyType); + init_thunk(&thunks[3], r, winIVRScreenshots_IVRScreenshots_001_GetScreenshotPropertyFilename); + init_thunk(&thunks[4], r, winIVRScreenshots_IVRScreenshots_001_UpdateScreenshotProgress); + init_thunk(&thunks[5], r, winIVRScreenshots_IVRScreenshots_001_TakeStereoScreenshot); + init_thunk(&thunks[6], r, winIVRScreenshots_IVRScreenshots_001_SubmitScreenshot); + for (i = 0; i < 7; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRScreenshots_IVRScreenshots_001_FnTable(void *object) +{ + winIVRScreenshots_IVRScreenshots_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRSettings.c b/vrclient_x64/winIVRSettings.c index bfb22c13..f2b82006 100644 --- a/vrclient_x64/winIVRSettings.c +++ b/vrclient_x64/winIVRSettings.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRSettings_IVRSettings_002.h" @@ -145,6 +147,42 @@ void destroy_winIVRSettings_IVRSettings_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSettings_IVRSettings_002 *create_winIVRSettings_IVRSettings_002_FnTable(void *linux_side) +{ + winIVRSettings_IVRSettings_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSettings_IVRSettings_002)); + struct thunk *thunks = alloc_thunks(12); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSettings_IVRSettings_002_GetSettingsErrorNameFromEnum); + init_thunk(&thunks[1], r, winIVRSettings_IVRSettings_002_Sync); + init_thunk(&thunks[2], r, winIVRSettings_IVRSettings_002_SetBool); + init_thunk(&thunks[3], r, winIVRSettings_IVRSettings_002_SetInt32); + init_thunk(&thunks[4], r, winIVRSettings_IVRSettings_002_SetFloat); + init_thunk(&thunks[5], r, winIVRSettings_IVRSettings_002_SetString); + init_thunk(&thunks[6], r, winIVRSettings_IVRSettings_002_GetBool); + init_thunk(&thunks[7], r, winIVRSettings_IVRSettings_002_GetInt32); + init_thunk(&thunks[8], r, winIVRSettings_IVRSettings_002_GetFloat); + init_thunk(&thunks[9], r, winIVRSettings_IVRSettings_002_GetString); + init_thunk(&thunks[10], r, winIVRSettings_IVRSettings_002_RemoveSection); + init_thunk(&thunks[11], r, winIVRSettings_IVRSettings_002_RemoveKeyInSection); + for (i = 0; i < 12; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSettings_IVRSettings_002_FnTable(void *object) +{ + winIVRSettings_IVRSettings_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSettings_IVRSettings_001.h" typedef struct __winIVRSettings_IVRSettings_001 { @@ -274,3 +312,39 @@ void destroy_winIVRSettings_IVRSettings_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSettings_IVRSettings_001 *create_winIVRSettings_IVRSettings_001_FnTable(void *linux_side) +{ + winIVRSettings_IVRSettings_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSettings_IVRSettings_001)); + struct thunk *thunks = alloc_thunks(12); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSettings_IVRSettings_001_GetSettingsErrorNameFromEnum); + init_thunk(&thunks[1], r, winIVRSettings_IVRSettings_001_Sync); + init_thunk(&thunks[2], r, winIVRSettings_IVRSettings_001_GetBool); + init_thunk(&thunks[3], r, winIVRSettings_IVRSettings_001_SetBool); + init_thunk(&thunks[4], r, winIVRSettings_IVRSettings_001_GetInt32); + init_thunk(&thunks[5], r, winIVRSettings_IVRSettings_001_SetInt32); + init_thunk(&thunks[6], r, winIVRSettings_IVRSettings_001_GetFloat); + init_thunk(&thunks[7], r, winIVRSettings_IVRSettings_001_SetFloat); + init_thunk(&thunks[8], r, winIVRSettings_IVRSettings_001_GetString); + init_thunk(&thunks[9], r, winIVRSettings_IVRSettings_001_SetString); + init_thunk(&thunks[10], r, winIVRSettings_IVRSettings_001_RemoveSection); + init_thunk(&thunks[11], r, winIVRSettings_IVRSettings_001_RemoveKeyInSection); + for (i = 0; i < 12; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSettings_IVRSettings_001_FnTable(void *object) +{ + winIVRSettings_IVRSettings_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRSystem.c b/vrclient_x64/winIVRSystem.c index 05b66b2b..5de42972 100644 --- a/vrclient_x64/winIVRSystem.c +++ b/vrclient_x64/winIVRSystem.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRSystem_IVRSystem_019.h" @@ -431,6 +433,77 @@ void destroy_winIVRSystem_IVRSystem_019(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_019 *create_winIVRSystem_IVRSystem_019_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_019 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_019)); + struct thunk *thunks = alloc_thunks(47); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 47 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_019_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_019_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_019_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_019_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_019_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_019_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_019_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_019_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_019_GetOutputDevice); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_019_IsDisplayOnDesktop); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_019_SetDisplayVisibility); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_019_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_019_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_019_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_019_ApplyTransform); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_019_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_019_GetTrackedDeviceClass); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_019_IsTrackedDeviceConnected); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_019_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_019_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_019_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_019_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_019_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_019_GetArrayTrackedDeviceProperty); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_019_GetStringTrackedDeviceProperty); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_019_PollNextEvent); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_019_PollNextEventWithPose); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_019_GetEventTypeNameFromEnum); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_019_GetHiddenAreaMesh); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_019_GetControllerState); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_019_GetControllerStateWithPose); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_019_TriggerHapticPulse); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_019_GetButtonIdNameFromEnum); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_019_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_019_IsInputAvailable); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_019_IsSteamVRDrawingControllers); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_019_ShouldApplicationPause); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_019_ShouldApplicationReduceRenderingWork); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_019_DriverDebugRequest); + init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_019_PerformFirmwareUpdate); + init_thunk(&thunks[45], r, winIVRSystem_IVRSystem_019_AcknowledgeQuit_Exiting); + init_thunk(&thunks[46], r, winIVRSystem_IVRSystem_019_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 47; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_019_FnTable(void *object) +{ + winIVRSystem_IVRSystem_019 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_017.h" typedef struct __winIVRSystem_IVRSystem_017 { @@ -830,6 +903,75 @@ void destroy_winIVRSystem_IVRSystem_017(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_017 *create_winIVRSystem_IVRSystem_017_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_017)); + struct thunk *thunks = alloc_thunks(45); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 45 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_017_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_017_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_017_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_017_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_017_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_017_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_017_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_017_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_017_GetOutputDevice); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_017_IsDisplayOnDesktop); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_017_SetDisplayVisibility); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_017_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_017_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_017_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_017_ApplyTransform); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_017_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_017_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_017_GetTrackedDeviceClass); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_017_IsTrackedDeviceConnected); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_017_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_017_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_017_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_017_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_017_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_017_GetStringTrackedDeviceProperty); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_017_GetPropErrorNameFromEnum); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_017_PollNextEvent); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_017_PollNextEventWithPose); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_017_GetEventTypeNameFromEnum); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_017_GetHiddenAreaMesh); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_017_GetControllerState); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_017_GetControllerStateWithPose); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_017_TriggerHapticPulse); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_017_GetButtonIdNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_017_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_017_CaptureInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_017_ReleaseInputFocus); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_017_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_017_DriverDebugRequest); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_017_PerformFirmwareUpdate); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_017_AcknowledgeQuit_Exiting); + init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_017_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 45; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_017_FnTable(void *object) +{ + winIVRSystem_IVRSystem_017 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_016.h" typedef struct __winIVRSystem_IVRSystem_016 { @@ -1229,6 +1371,75 @@ void destroy_winIVRSystem_IVRSystem_016(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_016 *create_winIVRSystem_IVRSystem_016_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_016 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_016)); + struct thunk *thunks = alloc_thunks(45); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 45 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_016_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_016_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_016_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_016_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_016_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_016_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_016_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_016_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_016_GetOutputDevice); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_016_IsDisplayOnDesktop); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_016_SetDisplayVisibility); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_016_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_016_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_016_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_016_ApplyTransform); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_016_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_016_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_016_GetTrackedDeviceClass); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_016_IsTrackedDeviceConnected); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_016_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_016_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_016_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_016_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_016_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_016_GetStringTrackedDeviceProperty); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_016_GetPropErrorNameFromEnum); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_016_PollNextEvent); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_016_PollNextEventWithPose); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_016_GetEventTypeNameFromEnum); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_016_GetHiddenAreaMesh); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_016_GetControllerState); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_016_GetControllerStateWithPose); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_016_TriggerHapticPulse); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_016_GetButtonIdNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_016_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_016_CaptureInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_016_ReleaseInputFocus); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_016_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_016_DriverDebugRequest); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_016_PerformFirmwareUpdate); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_016_AcknowledgeQuit_Exiting); + init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_016_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 45; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_016_FnTable(void *object) +{ + winIVRSystem_IVRSystem_016 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_015.h" typedef struct __winIVRSystem_IVRSystem_015 { @@ -1620,6 +1831,74 @@ void destroy_winIVRSystem_IVRSystem_015(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_015 *create_winIVRSystem_IVRSystem_015_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_015 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_015)); + struct thunk *thunks = alloc_thunks(44); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 44 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_015_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_015_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_015_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_015_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_015_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_015_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_015_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_015_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_015_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_015_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_015_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_015_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_015_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_015_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_015_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_015_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_015_GetTrackedDeviceClass); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_015_IsTrackedDeviceConnected); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_015_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_015_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_015_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_015_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_015_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_015_GetStringTrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_015_GetPropErrorNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_015_PollNextEvent); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_015_PollNextEventWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_015_GetEventTypeNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_015_GetHiddenAreaMesh); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_015_GetControllerState); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_015_GetControllerStateWithPose); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_015_TriggerHapticPulse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_015_GetButtonIdNameFromEnum); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_015_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_015_CaptureInputFocus); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_015_ReleaseInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_015_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_015_DriverDebugRequest); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_015_PerformFirmwareUpdate); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_015_AcknowledgeQuit_Exiting); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_015_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 44; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_015_FnTable(void *object) +{ + winIVRSystem_IVRSystem_015 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_014.h" typedef struct __winIVRSystem_IVRSystem_014 { @@ -2011,6 +2290,74 @@ void destroy_winIVRSystem_IVRSystem_014(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_014 *create_winIVRSystem_IVRSystem_014_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_014 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_014)); + struct thunk *thunks = alloc_thunks(44); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 44 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_014_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_014_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_014_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_014_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_014_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_014_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_014_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_014_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_014_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_014_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_014_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_014_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_014_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_014_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_014_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_014_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_014_GetTrackedDeviceClass); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_014_IsTrackedDeviceConnected); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_014_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_014_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_014_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_014_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_014_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_014_GetStringTrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_014_GetPropErrorNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_014_PollNextEvent); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_014_PollNextEventWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_014_GetEventTypeNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_014_GetHiddenAreaMesh); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_014_GetControllerState); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_014_GetControllerStateWithPose); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_014_TriggerHapticPulse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_014_GetButtonIdNameFromEnum); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_014_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_014_CaptureInputFocus); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_014_ReleaseInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_014_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_014_DriverDebugRequest); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_014_PerformFirmwareUpdate); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_014_AcknowledgeQuit_Exiting); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_014_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 44; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_014_FnTable(void *object) +{ + winIVRSystem_IVRSystem_014 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_012.h" typedef struct __winIVRSystem_IVRSystem_012 { @@ -2403,6 +2750,74 @@ void destroy_winIVRSystem_IVRSystem_012(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_012 *create_winIVRSystem_IVRSystem_012_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_012 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_012)); + struct thunk *thunks = alloc_thunks(44); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 44 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_012_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_012_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_012_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_012_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_012_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_012_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_012_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_012_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_012_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_012_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_012_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_012_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_012_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_012_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_012_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_012_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_012_GetTrackedDeviceClass); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_012_IsTrackedDeviceConnected); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_012_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_012_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_012_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_012_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_012_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_012_GetStringTrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_012_GetPropErrorNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_012_PollNextEvent); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_012_PollNextEventWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_012_GetEventTypeNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_012_GetHiddenAreaMesh); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_012_GetControllerState); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_012_GetControllerStateWithPose); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_012_TriggerHapticPulse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_012_GetButtonIdNameFromEnum); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_012_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_012_CaptureInputFocus); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_012_ReleaseInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_012_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_012_DriverDebugRequest); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_012_PerformFirmwareUpdate); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_012_AcknowledgeQuit_Exiting); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_012_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 44; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_012_FnTable(void *object) +{ + winIVRSystem_IVRSystem_012 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_011.h" typedef struct __winIVRSystem_IVRSystem_011 { @@ -2811,6 +3226,76 @@ void destroy_winIVRSystem_IVRSystem_011(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_011 *create_winIVRSystem_IVRSystem_011_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_011 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_011)); + struct thunk *thunks = alloc_thunks(46); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 46 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_011_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_011_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_011_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_011_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_011_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_011_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_011_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_011_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_011_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_011_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_011_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_011_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_011_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_011_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_011_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_011_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_011_GetTrackedDeviceClass); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_011_IsTrackedDeviceConnected); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_011_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_011_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_011_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_011_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_011_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_011_GetStringTrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_011_GetPropErrorNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_011_PollNextEvent); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_011_PollNextEventWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_011_GetEventTypeNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_011_GetHiddenAreaMesh); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_011_GetControllerState); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_011_GetControllerStateWithPose); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_011_TriggerHapticPulse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_011_GetButtonIdNameFromEnum); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_011_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_011_CaptureInputFocus); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_011_ReleaseInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_011_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_011_DriverDebugRequest); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_011_PerformFirmwareUpdate); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_011_AcknowledgeQuit_Exiting); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_011_AcknowledgeQuit_UserPrompt); + init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_011_PerformanceTestEnableCapture); + init_thunk(&thunks[45], r, winIVRSystem_IVRSystem_011_PerformanceTestReportFidelityLevelChange); + for (i = 0; i < 46; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_011_FnTable(void *object) +{ + winIVRSystem_IVRSystem_011 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_010.h" typedef struct __winIVRSystem_IVRSystem_010 { @@ -3219,6 +3704,76 @@ void destroy_winIVRSystem_IVRSystem_010(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_010 *create_winIVRSystem_IVRSystem_010_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_010 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_010)); + struct thunk *thunks = alloc_thunks(46); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 46 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_010_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_010_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_010_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_010_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_010_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_010_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_010_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_010_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_010_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_010_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_010_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_010_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_010_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_010_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_010_GetTrackedDeviceIndexForControllerRole); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_010_GetControllerRoleForTrackedDeviceIndex); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_010_GetTrackedDeviceClass); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_010_IsTrackedDeviceConnected); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_010_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_010_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_010_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_010_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_010_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_010_GetStringTrackedDeviceProperty); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_010_GetPropErrorNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_010_PollNextEvent); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_010_PollNextEventWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_010_GetEventTypeNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_010_GetHiddenAreaMesh); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_010_GetControllerState); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_010_GetControllerStateWithPose); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_010_TriggerHapticPulse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_010_GetButtonIdNameFromEnum); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_010_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_010_CaptureInputFocus); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_010_ReleaseInputFocus); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_010_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_010_DriverDebugRequest); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_010_PerformFirmwareUpdate); + init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_010_AcknowledgeQuit_Exiting); + init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_010_AcknowledgeQuit_UserPrompt); + init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_010_PerformanceTestEnableCapture); + init_thunk(&thunks[45], r, winIVRSystem_IVRSystem_010_PerformanceTestReportFidelityLevelChange); + for (i = 0; i < 46; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_010_FnTable(void *object) +{ + winIVRSystem_IVRSystem_010 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_009.h" typedef struct __winIVRSystem_IVRSystem_009 { @@ -3595,6 +4150,72 @@ void destroy_winIVRSystem_IVRSystem_009(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_009 *create_winIVRSystem_IVRSystem_009_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_009 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_009)); + struct thunk *thunks = alloc_thunks(42); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 42 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_009_GetRecommendedRenderTargetSize); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_009_GetProjectionMatrix); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_009_GetProjectionRaw); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_009_ComputeDistortion); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_009_GetEyeToHeadTransform); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_009_GetTimeSinceLastVsync); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_009_GetD3D9AdapterIndex); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_009_GetDXGIOutputInfo); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_009_IsDisplayOnDesktop); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_009_SetDisplayVisibility); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_009_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_009_ResetSeatedZeroPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_009_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_009_ApplyTransform); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_009_GetTrackedDeviceClass); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_009_IsTrackedDeviceConnected); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_009_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_009_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_009_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_009_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_009_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_009_GetStringTrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_009_GetPropErrorNameFromEnum); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_009_PollNextEvent); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_009_PollNextEventWithPose); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_009_GetEventTypeNameFromEnum); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_009_GetHiddenAreaMesh); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_009_GetControllerState); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_009_GetControllerStateWithPose); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_009_TriggerHapticPulse); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_009_GetButtonIdNameFromEnum); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_009_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_009_CaptureInputFocus); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_009_ReleaseInputFocus); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_009_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_009_DriverDebugRequest); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_009_PerformFirmwareUpdate); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_009_AcknowledgeQuit_Exiting); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_009_AcknowledgeQuit_UserPrompt); + for (i = 0; i < 42; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_009_FnTable(void *object) +{ + winIVRSystem_IVRSystem_009 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_006.h" typedef struct __winIVRSystem_IVRSystem_006 { @@ -3971,6 +4592,72 @@ void destroy_winIVRSystem_IVRSystem_006(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_006 *create_winIVRSystem_IVRSystem_006_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_006)); + struct thunk *thunks = alloc_thunks(42); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 42 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_006_GetWindowBounds); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_006_GetRecommendedRenderTargetSize); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_006_GetEyeOutputViewport); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_006_GetProjectionMatrix); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_006_GetProjectionRaw); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_006_ComputeDistortion); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_006_GetEyeToHeadTransform); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_006_GetTimeSinceLastVsync); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_006_GetD3D9AdapterIndex); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_006_GetDXGIOutputInfo); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_006_AttachToWindow); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_006_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_006_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_006_GetTrackedDeviceActivityLevel); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_006_GetTrackedDeviceClass); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_006_IsTrackedDeviceConnected); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_006_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_006_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_006_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_006_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_006_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_006_GetStringTrackedDeviceProperty); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_006_GetPropErrorNameFromEnum); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_006_PollNextEvent); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_006_PollNextEventWithPose); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_006_GetEventTypeNameFromEnum); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_006_GetHiddenAreaMesh); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_006_GetControllerState); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_006_GetControllerStateWithPose); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_006_TriggerHapticPulse); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_006_GetButtonIdNameFromEnum); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_006_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_006_CaptureInputFocus); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_006_ReleaseInputFocus); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_006_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_006_DriverDebugRequest); + init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_006_PerformFirmwareUpdate); + init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_006_IsDisplayOnDesktop); + init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_006_SetDisplayVisibility); + for (i = 0; i < 42; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_006_FnTable(void *object) +{ + winIVRSystem_IVRSystem_006 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_005.h" typedef struct __winIVRSystem_IVRSystem_005 { @@ -4306,6 +4993,67 @@ void destroy_winIVRSystem_IVRSystem_005(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_005 *create_winIVRSystem_IVRSystem_005_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_005 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_005)); + struct thunk *thunks = alloc_thunks(37); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 37 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_005_GetWindowBounds); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_005_GetRecommendedRenderTargetSize); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_005_GetEyeOutputViewport); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_005_GetProjectionMatrix); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_005_GetProjectionRaw); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_005_ComputeDistortion); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_005_GetEyeToHeadTransform); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_005_GetTimeSinceLastVsync); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_005_GetD3D9AdapterIndex); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_005_GetDXGIOutputInfo); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_005_AttachToWindow); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_005_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_005_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_005_GetTrackedDeviceClass); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_005_IsTrackedDeviceConnected); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_005_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_005_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_005_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_005_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_005_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_005_GetStringTrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_005_GetPropErrorNameFromEnum); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_005_PollNextEvent); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_005_PollNextEventWithPose); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_005_GetEventTypeNameFromEnum); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_005_GetHiddenAreaMesh); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_005_GetControllerState); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_005_GetControllerStateWithPose); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_005_TriggerHapticPulse); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_005_GetButtonIdNameFromEnum); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_005_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_005_CaptureInputFocus); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_005_ReleaseInputFocus); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_005_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_005_DriverDebugRequest); + for (i = 0; i < 37; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_005_FnTable(void *object) +{ + winIVRSystem_IVRSystem_005 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_004.h" typedef struct __winIVRSystem_IVRSystem_004 { @@ -4633,6 +5381,66 @@ void destroy_winIVRSystem_IVRSystem_004(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_004 *create_winIVRSystem_IVRSystem_004_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_004)); + struct thunk *thunks = alloc_thunks(36); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 36 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_004_GetWindowBounds); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_004_GetRecommendedRenderTargetSize); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_004_GetEyeOutputViewport); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_004_GetProjectionMatrix); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_004_GetProjectionRaw); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_004_ComputeDistortion); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_004_GetEyeToHeadTransform); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_004_GetTimeSinceLastVsync); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_004_GetD3D9AdapterIndex); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_004_GetDXGIOutputInfo); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_004_AttachToWindow); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_004_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_004_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_004_GetTrackedDeviceClass); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_004_IsTrackedDeviceConnected); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_004_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_004_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_004_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_004_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_004_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_004_GetStringTrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_004_GetPropErrorNameFromEnum); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_004_PollNextEvent); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_004_PollNextEventWithPose); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_004_GetEventTypeNameFromEnum); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_004_GetHiddenAreaMesh); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_004_GetControllerState); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_004_GetControllerStateWithPose); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_004_TriggerHapticPulse); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_004_GetButtonIdNameFromEnum); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_004_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_004_CaptureInputFocus); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_004_ReleaseInputFocus); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_004_IsInputFocusCapturedByAnotherProcess); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_004_DriverDebugRequest); + for (i = 0; i < 36; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_004_FnTable(void *object) +{ + winIVRSystem_IVRSystem_004 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRSystem_IVRSystem_003.h" typedef struct __winIVRSystem_IVRSystem_003 { @@ -4976,3 +5784,65 @@ void destroy_winIVRSystem_IVRSystem_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRSystem_IVRSystem_003 *create_winIVRSystem_IVRSystem_003_FnTable(void *linux_side) +{ + winIVRSystem_IVRSystem_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_003)); + struct thunk *thunks = alloc_thunks(38); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 38 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_003_GetWindowBounds); + init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_003_GetRecommendedRenderTargetSize); + init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_003_GetEyeOutputViewport); + init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_003_GetProjectionMatrix); + init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_003_GetProjectionRaw); + init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_003_ComputeDistortion); + init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_003_GetEyeToHeadTransform); + init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_003_GetTimeSinceLastVsync); + init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_003_GetD3D9AdapterIndex); + init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_003_GetDXGIOutputInfo); + init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_003_AttachToWindow); + init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_003_GetDeviceToAbsoluteTrackingPose); + init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_003_ResetSeatedZeroPose); + init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose); + init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_003_LoadRenderModel); + init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_003_FreeRenderModel); + init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_003_GetTrackedDeviceClass); + init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_003_IsTrackedDeviceConnected); + init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_003_GetBoolTrackedDeviceProperty); + init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_003_GetFloatTrackedDeviceProperty); + init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_003_GetInt32TrackedDeviceProperty); + init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_003_GetUint64TrackedDeviceProperty); + init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_003_GetMatrix34TrackedDeviceProperty); + init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_003_GetStringTrackedDeviceProperty); + init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_003_GetPropErrorNameFromEnum); + init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_003_PollNextEvent); + init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_003_PollNextEventWithPose); + init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_003_GetEventTypeNameFromEnum); + init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_003_GetHiddenAreaMesh); + init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_003_GetControllerState); + init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_003_GetControllerStateWithPose); + init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_003_TriggerHapticPulse); + init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_003_GetButtonIdNameFromEnum); + init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_003_GetControllerAxisTypeNameFromEnum); + init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_003_HandleControllerOverlayInteractionAsMouse); + init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_003_CaptureInputFocus); + init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_003_ReleaseInputFocus); + init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_003_IsInputFocusCapturedByAnotherProcess); + for (i = 0; i < 38; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRSystem_IVRSystem_003_FnTable(void *object) +{ + winIVRSystem_IVRSystem_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/winIVRTrackedCamera.c b/vrclient_x64/winIVRTrackedCamera.c index 0bbbb99f..a5cfa5a8 100644 --- a/vrclient_x64/winIVRTrackedCamera.c +++ b/vrclient_x64/winIVRTrackedCamera.c @@ -14,6 +14,8 @@ #include "struct_converters.h" +#include "flatapi.h" + WINE_DEFAULT_DEBUG_CHANNEL(vrclient); #include "cppIVRTrackedCamera_IVRTrackedCamera_003.h" @@ -145,6 +147,42 @@ void destroy_winIVRTrackedCamera_IVRTrackedCamera_003(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRTrackedCamera_IVRTrackedCamera_003 *create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *linux_side) +{ + winIVRTrackedCamera_IVRTrackedCamera_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRTrackedCamera_IVRTrackedCamera_003)); + struct thunk *thunks = alloc_thunks(12); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetCameraErrorNameFromEnum); + init_thunk(&thunks[1], r, winIVRTrackedCamera_IVRTrackedCamera_003_HasCamera); + init_thunk(&thunks[2], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetCameraFrameSize); + init_thunk(&thunks[3], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetCameraIntrinsics); + init_thunk(&thunks[4], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetCameraProjection); + init_thunk(&thunks[5], r, winIVRTrackedCamera_IVRTrackedCamera_003_AcquireVideoStreamingService); + init_thunk(&thunks[6], r, winIVRTrackedCamera_IVRTrackedCamera_003_ReleaseVideoStreamingService); + init_thunk(&thunks[7], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetVideoStreamFrameBuffer); + init_thunk(&thunks[8], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetVideoStreamTextureSize); + init_thunk(&thunks[9], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetVideoStreamTextureD3D11); + init_thunk(&thunks[10], r, winIVRTrackedCamera_IVRTrackedCamera_003_GetVideoStreamTextureGL); + init_thunk(&thunks[11], r, winIVRTrackedCamera_IVRTrackedCamera_003_ReleaseVideoStreamTextureGL); + for (i = 0; i < 12; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *object) +{ + winIVRTrackedCamera_IVRTrackedCamera_003 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRTrackedCamera_IVRTrackedCamera_002.h" typedef struct __winIVRTrackedCamera_IVRTrackedCamera_002 { @@ -242,6 +280,38 @@ void destroy_winIVRTrackedCamera_IVRTrackedCamera_002(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRTrackedCamera_IVRTrackedCamera_002 *create_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable(void *linux_side) +{ + winIVRTrackedCamera_IVRTrackedCamera_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRTrackedCamera_IVRTrackedCamera_002)); + struct thunk *thunks = alloc_thunks(8); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 8 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRTrackedCamera_IVRTrackedCamera_002_GetCameraErrorNameFromEnum); + init_thunk(&thunks[1], r, winIVRTrackedCamera_IVRTrackedCamera_002_HasCamera); + init_thunk(&thunks[2], r, winIVRTrackedCamera_IVRTrackedCamera_002_GetCameraFrameSize); + init_thunk(&thunks[3], r, winIVRTrackedCamera_IVRTrackedCamera_002_GetCameraIntrinisics); + init_thunk(&thunks[4], r, winIVRTrackedCamera_IVRTrackedCamera_002_GetCameraProjection); + init_thunk(&thunks[5], r, winIVRTrackedCamera_IVRTrackedCamera_002_AcquireVideoStreamingService); + init_thunk(&thunks[6], r, winIVRTrackedCamera_IVRTrackedCamera_002_ReleaseVideoStreamingService); + init_thunk(&thunks[7], r, winIVRTrackedCamera_IVRTrackedCamera_002_GetVideoStreamFrameBuffer); + for (i = 0; i < 8; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable(void *object) +{ + winIVRTrackedCamera_IVRTrackedCamera_002 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + #include "cppIVRTrackedCamera_IVRTrackedCamera_001.h" typedef struct __winIVRTrackedCamera_IVRTrackedCamera_001 { @@ -419,3 +489,45 @@ void destroy_winIVRTrackedCamera_IVRTrackedCamera_001(void *object) HeapFree(GetProcessHeap(), 0, object); } +winIVRTrackedCamera_IVRTrackedCamera_001 *create_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable(void *linux_side) +{ + winIVRTrackedCamera_IVRTrackedCamera_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRTrackedCamera_IVRTrackedCamera_001)); + struct thunk *thunks = alloc_thunks(18); + struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 18 * sizeof(*vtable)); + int i; + + TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks); + init_thunk(&thunks[0], r, winIVRTrackedCamera_IVRTrackedCamera_001_HasCamera); + init_thunk(&thunks[1], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetCameraFirmwareDescription); + init_thunk(&thunks[2], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetCameraFrameDimensions); + init_thunk(&thunks[3], r, winIVRTrackedCamera_IVRTrackedCamera_001_SetCameraVideoStreamFormat); + init_thunk(&thunks[4], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetCameraVideoStreamFormat); + init_thunk(&thunks[5], r, winIVRTrackedCamera_IVRTrackedCamera_001_EnableCameraForStreaming); + init_thunk(&thunks[6], r, winIVRTrackedCamera_IVRTrackedCamera_001_StartVideoStream); + init_thunk(&thunks[7], r, winIVRTrackedCamera_IVRTrackedCamera_001_StopVideoStream); + init_thunk(&thunks[8], r, winIVRTrackedCamera_IVRTrackedCamera_001_IsVideoStreamActive); + init_thunk(&thunks[9], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetVideoStreamElapsedTime); + init_thunk(&thunks[10], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetVideoStreamFrame); + init_thunk(&thunks[11], r, winIVRTrackedCamera_IVRTrackedCamera_001_ReleaseVideoStreamFrame); + init_thunk(&thunks[12], r, winIVRTrackedCamera_IVRTrackedCamera_001_SetAutoExposure); + init_thunk(&thunks[13], r, winIVRTrackedCamera_IVRTrackedCamera_001_PauseVideoStream); + init_thunk(&thunks[14], r, winIVRTrackedCamera_IVRTrackedCamera_001_ResumeVideoStream); + init_thunk(&thunks[15], r, winIVRTrackedCamera_IVRTrackedCamera_001_IsVideoStreamPaused); + init_thunk(&thunks[16], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetCameraDistortion); + init_thunk(&thunks[17], r, winIVRTrackedCamera_IVRTrackedCamera_001_GetCameraProjection); + for (i = 0; i < 18; i++) + vtable[i] = &thunks[i]; + r->linux_side = linux_side; + r->vtable = (void *)vtable; + return r; +} + +void destroy_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable(void *object) +{ + winIVRTrackedCamera_IVRTrackedCamera_001 *win_object = object; + TRACE("%p\n", win_object); + VirtualFree(win_object->vtable[0], 0, MEM_RELEASE); + HeapFree(GetProcessHeap(), 0, win_object->vtable); + HeapFree(GetProcessHeap(), 0, win_object); +} + diff --git a/vrclient_x64/win_constructors.h b/vrclient_x64/win_constructors.h index a9c9e844..cc5c97ee 100644 --- a/vrclient_x64/win_constructors.h +++ b/vrclient_x64/win_constructors.h @@ -1,72 +1,144 @@ extern void *create_winIVRSystem_IVRSystem_019(void *); +extern void *create_winIVRSystem_IVRSystem_019_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_006(void *); +extern void *create_winIVRApplications_IVRApplications_006_FnTable(void *); extern void *create_winIVRSettings_IVRSettings_002(void *); +extern void *create_winIVRSettings_IVRSettings_002_FnTable(void *); extern void *create_winIVRChaperone_IVRChaperone_003(void *); +extern void *create_winIVRChaperone_IVRChaperone_003_FnTable(void *); extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *); +extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_022(void *); +extern void *create_winIVRCompositor_IVRCompositor_022_FnTable(void *); extern void *create_winIVRNotifications_IVRNotifications_002(void *); +extern void *create_winIVRNotifications_IVRNotifications_002_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_018(void *); +extern void *create_winIVROverlay_IVROverlay_018_FnTable(void *); extern void *create_winIVRRenderModels_IVRRenderModels_005(void *); +extern void *create_winIVRRenderModels_IVRRenderModels_005_FnTable(void *); extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *); +extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *); extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003(void *); +extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *); extern void *create_winIVRScreenshots_IVRScreenshots_001(void *); +extern void *create_winIVRScreenshots_IVRScreenshots_001_FnTable(void *); extern void *create_winIVRResources_IVRResources_001(void *); +extern void *create_winIVRResources_IVRResources_001_FnTable(void *); extern void *create_winIVRDriverManager_IVRDriverManager_001(void *); +extern void *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *); extern void *create_winIVRClientCore_IVRClientCore_003(void *); +extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_017(void *); +extern void *create_winIVRSystem_IVRSystem_017_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_017(void *); +extern void *create_winIVROverlay_IVROverlay_017_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_021(void *); +extern void *create_winIVRCompositor_IVRCompositor_021_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_016(void *); +extern void *create_winIVROverlay_IVROverlay_016_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_016(void *); +extern void *create_winIVRSystem_IVRSystem_016_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_020(void *); +extern void *create_winIVRCompositor_IVRCompositor_020_FnTable(void *); extern void *create_winIVRClientCore_IVRClientCore_002(void *); +extern void *create_winIVRClientCore_IVRClientCore_002_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_015(void *); +extern void *create_winIVRSystem_IVRSystem_015_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_014(void *); +extern void *create_winIVROverlay_IVROverlay_014_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_019(void *); +extern void *create_winIVRCompositor_IVRCompositor_019_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_014(void *); +extern void *create_winIVRSystem_IVRSystem_014_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_018(void *); +extern void *create_winIVRCompositor_IVRCompositor_018_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_013(void *); +extern void *create_winIVROverlay_IVROverlay_013_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_012(void *); +extern void *create_winIVRSystem_IVRSystem_012_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_016(void *); +extern void *create_winIVRCompositor_IVRCompositor_016_FnTable(void *); extern void *create_winIVRSettings_IVRSettings_001(void *); +extern void *create_winIVRSettings_IVRSettings_001_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_005(void *); +extern void *create_winIVRApplications_IVRApplications_005_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_015(void *); +extern void *create_winIVRCompositor_IVRCompositor_015_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_012(void *); +extern void *create_winIVROverlay_IVROverlay_012_FnTable(void *); extern void *create_winIVRTrackedCamera_IVRTrackedCamera_002(void *); +extern void *create_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_014(void *); +extern void *create_winIVRCompositor_IVRCompositor_014_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_011(void *); +extern void *create_winIVROverlay_IVROverlay_011_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_013(void *); +extern void *create_winIVRCompositor_IVRCompositor_013_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_011(void *); +extern void *create_winIVRSystem_IVRSystem_011_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_004(void *); +extern void *create_winIVRApplications_IVRApplications_004_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_010(void *); +extern void *create_winIVROverlay_IVROverlay_010_FnTable(void *); extern void *create_winIVRRenderModels_IVRRenderModels_004(void *); +extern void *create_winIVRRenderModels_IVRRenderModels_004_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_012(void *); +extern void *create_winIVRCompositor_IVRCompositor_012_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_003(void *); +extern void *create_winIVRApplications_IVRApplications_003_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_011(void *); +extern void *create_winIVRCompositor_IVRCompositor_011_FnTable(void *); extern void *create_winIVRRenderModels_IVRRenderModels_002(void *); +extern void *create_winIVRRenderModels_IVRRenderModels_002_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_010(void *); +extern void *create_winIVRSystem_IVRSystem_010_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_002(void *); +extern void *create_winIVRApplications_IVRApplications_002_FnTable(void *); extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_004(void *); +extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_010(void *); +extern void *create_winIVRCompositor_IVRCompositor_010_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_008(void *); +extern void *create_winIVROverlay_IVROverlay_008_FnTable(void *); extern void *create_winIVRTrackedCamera_IVRTrackedCamera_001(void *); +extern void *create_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_009(void *); +extern void *create_winIVRCompositor_IVRCompositor_009_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_009(void *); +extern void *create_winIVRSystem_IVRSystem_009_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_007(void *); +extern void *create_winIVROverlay_IVROverlay_007_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_006(void *); +extern void *create_winIVRSystem_IVRSystem_006_FnTable(void *); extern void *create_winIVRApplications_IVRApplications_001(void *); +extern void *create_winIVRApplications_IVRApplications_001_FnTable(void *); extern void *create_winIVRChaperone_IVRChaperone_002(void *); +extern void *create_winIVRChaperone_IVRChaperone_002_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_008(void *); +extern void *create_winIVRCompositor_IVRCompositor_008_FnTable(void *); extern void *create_winIVRNotifications_IVRNotifications_001(void *); +extern void *create_winIVRNotifications_IVRNotifications_001_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_005(void *); +extern void *create_winIVROverlay_IVROverlay_005_FnTable(void *); extern void *create_winIVRRenderModels_IVRRenderModels_001(void *); +extern void *create_winIVRRenderModels_IVRRenderModels_001_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_005(void *); +extern void *create_winIVRSystem_IVRSystem_005_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_007(void *); +extern void *create_winIVRCompositor_IVRCompositor_007_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_004(void *); +extern void *create_winIVROverlay_IVROverlay_004_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_003(void *); +extern void *create_winIVROverlay_IVROverlay_003_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_002(void *); +extern void *create_winIVROverlay_IVROverlay_002_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_004(void *); +extern void *create_winIVRSystem_IVRSystem_004_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_006(void *); +extern void *create_winIVRCompositor_IVRCompositor_006_FnTable(void *); extern void *create_winIVROverlay_IVROverlay_001(void *); +extern void *create_winIVROverlay_IVROverlay_001_FnTable(void *); extern void *create_winIVRSystem_IVRSystem_003(void *); +extern void *create_winIVRSystem_IVRSystem_003_FnTable(void *); extern void *create_winIVRCompositor_IVRCompositor_005(void *); +extern void *create_winIVRCompositor_IVRCompositor_005_FnTable(void *); diff --git a/vrclient_x64/win_constructors_table.dat b/vrclient_x64/win_constructors_table.dat index 4e69e1ef..95e3c7f2 100644 --- a/vrclient_x64/win_constructors_table.dat +++ b/vrclient_x64/win_constructors_table.dat @@ -1,72 +1,144 @@ {"IVRSystem_019", &create_winIVRSystem_IVRSystem_019, &destroy_winIVRSystem_IVRSystem_019}, + {"FnTable:IVRSystem_019", &create_winIVRSystem_IVRSystem_019_FnTable, &destroy_winIVRSystem_IVRSystem_019_FnTable}, {"IVRApplications_006", &create_winIVRApplications_IVRApplications_006, &destroy_winIVRApplications_IVRApplications_006}, + {"FnTable:IVRApplications_006", &create_winIVRApplications_IVRApplications_006_FnTable, &destroy_winIVRApplications_IVRApplications_006_FnTable}, {"IVRSettings_002", &create_winIVRSettings_IVRSettings_002, &destroy_winIVRSettings_IVRSettings_002}, + {"FnTable:IVRSettings_002", &create_winIVRSettings_IVRSettings_002_FnTable, &destroy_winIVRSettings_IVRSettings_002_FnTable}, {"IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003, &destroy_winIVRChaperone_IVRChaperone_003}, + {"FnTable:IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003_FnTable, &destroy_winIVRChaperone_IVRChaperone_003_FnTable}, {"IVRChaperoneSetup_005", &create_winIVRChaperoneSetup_IVRChaperoneSetup_005, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005}, + {"FnTable:IVRChaperoneSetup_005", &create_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable}, {"IVRCompositor_022", &create_winIVRCompositor_IVRCompositor_022, &destroy_winIVRCompositor_IVRCompositor_022}, + {"FnTable:IVRCompositor_022", &create_winIVRCompositor_IVRCompositor_022_FnTable, &destroy_winIVRCompositor_IVRCompositor_022_FnTable}, {"IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002, &destroy_winIVRNotifications_IVRNotifications_002}, + {"FnTable:IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002_FnTable, &destroy_winIVRNotifications_IVRNotifications_002_FnTable}, {"IVROverlay_018", &create_winIVROverlay_IVROverlay_018, &destroy_winIVROverlay_IVROverlay_018}, + {"FnTable:IVROverlay_018", &create_winIVROverlay_IVROverlay_018_FnTable, &destroy_winIVROverlay_IVROverlay_018_FnTable}, {"IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005, &destroy_winIVRRenderModels_IVRRenderModels_005}, + {"FnTable:IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_005_FnTable}, {"IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001}, + {"FnTable:IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable}, {"IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003}, + {"FnTable:IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable}, {"IVRScreenshots_001", &create_winIVRScreenshots_IVRScreenshots_001, &destroy_winIVRScreenshots_IVRScreenshots_001}, + {"FnTable:IVRScreenshots_001", &create_winIVRScreenshots_IVRScreenshots_001_FnTable, &destroy_winIVRScreenshots_IVRScreenshots_001_FnTable}, {"IVRResources_001", &create_winIVRResources_IVRResources_001, &destroy_winIVRResources_IVRResources_001}, + {"FnTable:IVRResources_001", &create_winIVRResources_IVRResources_001_FnTable, &destroy_winIVRResources_IVRResources_001_FnTable}, {"IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001, &destroy_winIVRDriverManager_IVRDriverManager_001}, + {"FnTable:IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001_FnTable, &destroy_winIVRDriverManager_IVRDriverManager_001_FnTable}, {"IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003, &destroy_winIVRClientCore_IVRClientCore_003}, + {"FnTable:IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003_FnTable, &destroy_winIVRClientCore_IVRClientCore_003_FnTable}, {"IVRSystem_017", &create_winIVRSystem_IVRSystem_017, &destroy_winIVRSystem_IVRSystem_017}, + {"FnTable:IVRSystem_017", &create_winIVRSystem_IVRSystem_017_FnTable, &destroy_winIVRSystem_IVRSystem_017_FnTable}, {"IVROverlay_017", &create_winIVROverlay_IVROverlay_017, &destroy_winIVROverlay_IVROverlay_017}, + {"FnTable:IVROverlay_017", &create_winIVROverlay_IVROverlay_017_FnTable, &destroy_winIVROverlay_IVROverlay_017_FnTable}, {"IVRCompositor_021", &create_winIVRCompositor_IVRCompositor_021, &destroy_winIVRCompositor_IVRCompositor_021}, + {"FnTable:IVRCompositor_021", &create_winIVRCompositor_IVRCompositor_021_FnTable, &destroy_winIVRCompositor_IVRCompositor_021_FnTable}, {"IVROverlay_016", &create_winIVROverlay_IVROverlay_016, &destroy_winIVROverlay_IVROverlay_016}, + {"FnTable:IVROverlay_016", &create_winIVROverlay_IVROverlay_016_FnTable, &destroy_winIVROverlay_IVROverlay_016_FnTable}, {"IVRSystem_016", &create_winIVRSystem_IVRSystem_016, &destroy_winIVRSystem_IVRSystem_016}, + {"FnTable:IVRSystem_016", &create_winIVRSystem_IVRSystem_016_FnTable, &destroy_winIVRSystem_IVRSystem_016_FnTable}, {"IVRCompositor_020", &create_winIVRCompositor_IVRCompositor_020, &destroy_winIVRCompositor_IVRCompositor_020}, + {"FnTable:IVRCompositor_020", &create_winIVRCompositor_IVRCompositor_020_FnTable, &destroy_winIVRCompositor_IVRCompositor_020_FnTable}, {"IVRClientCore_002", &create_winIVRClientCore_IVRClientCore_002, &destroy_winIVRClientCore_IVRClientCore_002}, + {"FnTable:IVRClientCore_002", &create_winIVRClientCore_IVRClientCore_002_FnTable, &destroy_winIVRClientCore_IVRClientCore_002_FnTable}, {"IVRSystem_015", &create_winIVRSystem_IVRSystem_015, &destroy_winIVRSystem_IVRSystem_015}, + {"FnTable:IVRSystem_015", &create_winIVRSystem_IVRSystem_015_FnTable, &destroy_winIVRSystem_IVRSystem_015_FnTable}, {"IVROverlay_014", &create_winIVROverlay_IVROverlay_014, &destroy_winIVROverlay_IVROverlay_014}, + {"FnTable:IVROverlay_014", &create_winIVROverlay_IVROverlay_014_FnTable, &destroy_winIVROverlay_IVROverlay_014_FnTable}, {"IVRCompositor_019", &create_winIVRCompositor_IVRCompositor_019, &destroy_winIVRCompositor_IVRCompositor_019}, + {"FnTable:IVRCompositor_019", &create_winIVRCompositor_IVRCompositor_019_FnTable, &destroy_winIVRCompositor_IVRCompositor_019_FnTable}, {"IVRSystem_014", &create_winIVRSystem_IVRSystem_014, &destroy_winIVRSystem_IVRSystem_014}, + {"FnTable:IVRSystem_014", &create_winIVRSystem_IVRSystem_014_FnTable, &destroy_winIVRSystem_IVRSystem_014_FnTable}, {"IVRCompositor_018", &create_winIVRCompositor_IVRCompositor_018, &destroy_winIVRCompositor_IVRCompositor_018}, + {"FnTable:IVRCompositor_018", &create_winIVRCompositor_IVRCompositor_018_FnTable, &destroy_winIVRCompositor_IVRCompositor_018_FnTable}, {"IVROverlay_013", &create_winIVROverlay_IVROverlay_013, &destroy_winIVROverlay_IVROverlay_013}, + {"FnTable:IVROverlay_013", &create_winIVROverlay_IVROverlay_013_FnTable, &destroy_winIVROverlay_IVROverlay_013_FnTable}, {"IVRSystem_012", &create_winIVRSystem_IVRSystem_012, &destroy_winIVRSystem_IVRSystem_012}, + {"FnTable:IVRSystem_012", &create_winIVRSystem_IVRSystem_012_FnTable, &destroy_winIVRSystem_IVRSystem_012_FnTable}, {"IVRCompositor_016", &create_winIVRCompositor_IVRCompositor_016, &destroy_winIVRCompositor_IVRCompositor_016}, + {"FnTable:IVRCompositor_016", &create_winIVRCompositor_IVRCompositor_016_FnTable, &destroy_winIVRCompositor_IVRCompositor_016_FnTable}, {"IVRSettings_001", &create_winIVRSettings_IVRSettings_001, &destroy_winIVRSettings_IVRSettings_001}, + {"FnTable:IVRSettings_001", &create_winIVRSettings_IVRSettings_001_FnTable, &destroy_winIVRSettings_IVRSettings_001_FnTable}, {"IVRApplications_005", &create_winIVRApplications_IVRApplications_005, &destroy_winIVRApplications_IVRApplications_005}, + {"FnTable:IVRApplications_005", &create_winIVRApplications_IVRApplications_005_FnTable, &destroy_winIVRApplications_IVRApplications_005_FnTable}, {"IVRCompositor_015", &create_winIVRCompositor_IVRCompositor_015, &destroy_winIVRCompositor_IVRCompositor_015}, + {"FnTable:IVRCompositor_015", &create_winIVRCompositor_IVRCompositor_015_FnTable, &destroy_winIVRCompositor_IVRCompositor_015_FnTable}, {"IVROverlay_012", &create_winIVROverlay_IVROverlay_012, &destroy_winIVROverlay_IVROverlay_012}, + {"FnTable:IVROverlay_012", &create_winIVROverlay_IVROverlay_012_FnTable, &destroy_winIVROverlay_IVROverlay_012_FnTable}, {"IVRTrackedCamera_002", &create_winIVRTrackedCamera_IVRTrackedCamera_002, &destroy_winIVRTrackedCamera_IVRTrackedCamera_002}, + {"FnTable:IVRTrackedCamera_002", &create_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable}, {"IVRCompositor_014", &create_winIVRCompositor_IVRCompositor_014, &destroy_winIVRCompositor_IVRCompositor_014}, + {"FnTable:IVRCompositor_014", &create_winIVRCompositor_IVRCompositor_014_FnTable, &destroy_winIVRCompositor_IVRCompositor_014_FnTable}, {"IVROverlay_011", &create_winIVROverlay_IVROverlay_011, &destroy_winIVROverlay_IVROverlay_011}, + {"FnTable:IVROverlay_011", &create_winIVROverlay_IVROverlay_011_FnTable, &destroy_winIVROverlay_IVROverlay_011_FnTable}, {"IVRCompositor_013", &create_winIVRCompositor_IVRCompositor_013, &destroy_winIVRCompositor_IVRCompositor_013}, + {"FnTable:IVRCompositor_013", &create_winIVRCompositor_IVRCompositor_013_FnTable, &destroy_winIVRCompositor_IVRCompositor_013_FnTable}, {"IVRSystem_011", &create_winIVRSystem_IVRSystem_011, &destroy_winIVRSystem_IVRSystem_011}, + {"FnTable:IVRSystem_011", &create_winIVRSystem_IVRSystem_011_FnTable, &destroy_winIVRSystem_IVRSystem_011_FnTable}, {"IVRApplications_004", &create_winIVRApplications_IVRApplications_004, &destroy_winIVRApplications_IVRApplications_004}, + {"FnTable:IVRApplications_004", &create_winIVRApplications_IVRApplications_004_FnTable, &destroy_winIVRApplications_IVRApplications_004_FnTable}, {"IVROverlay_010", &create_winIVROverlay_IVROverlay_010, &destroy_winIVROverlay_IVROverlay_010}, + {"FnTable:IVROverlay_010", &create_winIVROverlay_IVROverlay_010_FnTable, &destroy_winIVROverlay_IVROverlay_010_FnTable}, {"IVRRenderModels_004", &create_winIVRRenderModels_IVRRenderModels_004, &destroy_winIVRRenderModels_IVRRenderModels_004}, + {"FnTable:IVRRenderModels_004", &create_winIVRRenderModels_IVRRenderModels_004_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_004_FnTable}, {"IVRCompositor_012", &create_winIVRCompositor_IVRCompositor_012, &destroy_winIVRCompositor_IVRCompositor_012}, + {"FnTable:IVRCompositor_012", &create_winIVRCompositor_IVRCompositor_012_FnTable, &destroy_winIVRCompositor_IVRCompositor_012_FnTable}, {"IVRApplications_003", &create_winIVRApplications_IVRApplications_003, &destroy_winIVRApplications_IVRApplications_003}, + {"FnTable:IVRApplications_003", &create_winIVRApplications_IVRApplications_003_FnTable, &destroy_winIVRApplications_IVRApplications_003_FnTable}, {"IVRCompositor_011", &create_winIVRCompositor_IVRCompositor_011, &destroy_winIVRCompositor_IVRCompositor_011}, + {"FnTable:IVRCompositor_011", &create_winIVRCompositor_IVRCompositor_011_FnTable, &destroy_winIVRCompositor_IVRCompositor_011_FnTable}, {"IVRRenderModels_002", &create_winIVRRenderModels_IVRRenderModels_002, &destroy_winIVRRenderModels_IVRRenderModels_002}, + {"FnTable:IVRRenderModels_002", &create_winIVRRenderModels_IVRRenderModels_002_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_002_FnTable}, {"IVRSystem_010", &create_winIVRSystem_IVRSystem_010, &destroy_winIVRSystem_IVRSystem_010}, + {"FnTable:IVRSystem_010", &create_winIVRSystem_IVRSystem_010_FnTable, &destroy_winIVRSystem_IVRSystem_010_FnTable}, {"IVRApplications_002", &create_winIVRApplications_IVRApplications_002, &destroy_winIVRApplications_IVRApplications_002}, + {"FnTable:IVRApplications_002", &create_winIVRApplications_IVRApplications_002_FnTable, &destroy_winIVRApplications_IVRApplications_002_FnTable}, {"IVRChaperoneSetup_004", &create_winIVRChaperoneSetup_IVRChaperoneSetup_004, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004}, + {"FnTable:IVRChaperoneSetup_004", &create_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable}, {"IVRCompositor_010", &create_winIVRCompositor_IVRCompositor_010, &destroy_winIVRCompositor_IVRCompositor_010}, + {"FnTable:IVRCompositor_010", &create_winIVRCompositor_IVRCompositor_010_FnTable, &destroy_winIVRCompositor_IVRCompositor_010_FnTable}, {"IVROverlay_008", &create_winIVROverlay_IVROverlay_008, &destroy_winIVROverlay_IVROverlay_008}, + {"FnTable:IVROverlay_008", &create_winIVROverlay_IVROverlay_008_FnTable, &destroy_winIVROverlay_IVROverlay_008_FnTable}, {"IVRTrackedCamera_001", &create_winIVRTrackedCamera_IVRTrackedCamera_001, &destroy_winIVRTrackedCamera_IVRTrackedCamera_001}, + {"FnTable:IVRTrackedCamera_001", &create_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable}, {"IVRCompositor_009", &create_winIVRCompositor_IVRCompositor_009, &destroy_winIVRCompositor_IVRCompositor_009}, + {"FnTable:IVRCompositor_009", &create_winIVRCompositor_IVRCompositor_009_FnTable, &destroy_winIVRCompositor_IVRCompositor_009_FnTable}, {"IVRSystem_009", &create_winIVRSystem_IVRSystem_009, &destroy_winIVRSystem_IVRSystem_009}, + {"FnTable:IVRSystem_009", &create_winIVRSystem_IVRSystem_009_FnTable, &destroy_winIVRSystem_IVRSystem_009_FnTable}, {"IVROverlay_007", &create_winIVROverlay_IVROverlay_007, &destroy_winIVROverlay_IVROverlay_007}, + {"FnTable:IVROverlay_007", &create_winIVROverlay_IVROverlay_007_FnTable, &destroy_winIVROverlay_IVROverlay_007_FnTable}, {"IVRSystem_006", &create_winIVRSystem_IVRSystem_006, &destroy_winIVRSystem_IVRSystem_006}, + {"FnTable:IVRSystem_006", &create_winIVRSystem_IVRSystem_006_FnTable, &destroy_winIVRSystem_IVRSystem_006_FnTable}, {"IVRApplications_001", &create_winIVRApplications_IVRApplications_001, &destroy_winIVRApplications_IVRApplications_001}, + {"FnTable:IVRApplications_001", &create_winIVRApplications_IVRApplications_001_FnTable, &destroy_winIVRApplications_IVRApplications_001_FnTable}, {"IVRChaperone_002", &create_winIVRChaperone_IVRChaperone_002, &destroy_winIVRChaperone_IVRChaperone_002}, + {"FnTable:IVRChaperone_002", &create_winIVRChaperone_IVRChaperone_002_FnTable, &destroy_winIVRChaperone_IVRChaperone_002_FnTable}, {"IVRCompositor_008", &create_winIVRCompositor_IVRCompositor_008, &destroy_winIVRCompositor_IVRCompositor_008}, + {"FnTable:IVRCompositor_008", &create_winIVRCompositor_IVRCompositor_008_FnTable, &destroy_winIVRCompositor_IVRCompositor_008_FnTable}, {"IVRNotifications_001", &create_winIVRNotifications_IVRNotifications_001, &destroy_winIVRNotifications_IVRNotifications_001}, + {"FnTable:IVRNotifications_001", &create_winIVRNotifications_IVRNotifications_001_FnTable, &destroy_winIVRNotifications_IVRNotifications_001_FnTable}, {"IVROverlay_005", &create_winIVROverlay_IVROverlay_005, &destroy_winIVROverlay_IVROverlay_005}, + {"FnTable:IVROverlay_005", &create_winIVROverlay_IVROverlay_005_FnTable, &destroy_winIVROverlay_IVROverlay_005_FnTable}, {"IVRRenderModels_001", &create_winIVRRenderModels_IVRRenderModels_001, &destroy_winIVRRenderModels_IVRRenderModels_001}, + {"FnTable:IVRRenderModels_001", &create_winIVRRenderModels_IVRRenderModels_001_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_001_FnTable}, {"IVRSystem_005", &create_winIVRSystem_IVRSystem_005, &destroy_winIVRSystem_IVRSystem_005}, + {"FnTable:IVRSystem_005", &create_winIVRSystem_IVRSystem_005_FnTable, &destroy_winIVRSystem_IVRSystem_005_FnTable}, {"IVRCompositor_007", &create_winIVRCompositor_IVRCompositor_007, &destroy_winIVRCompositor_IVRCompositor_007}, + {"FnTable:IVRCompositor_007", &create_winIVRCompositor_IVRCompositor_007_FnTable, &destroy_winIVRCompositor_IVRCompositor_007_FnTable}, {"IVROverlay_004", &create_winIVROverlay_IVROverlay_004, &destroy_winIVROverlay_IVROverlay_004}, + {"FnTable:IVROverlay_004", &create_winIVROverlay_IVROverlay_004_FnTable, &destroy_winIVROverlay_IVROverlay_004_FnTable}, {"IVROverlay_003", &create_winIVROverlay_IVROverlay_003, &destroy_winIVROverlay_IVROverlay_003}, + {"FnTable:IVROverlay_003", &create_winIVROverlay_IVROverlay_003_FnTable, &destroy_winIVROverlay_IVROverlay_003_FnTable}, {"IVROverlay_002", &create_winIVROverlay_IVROverlay_002, &destroy_winIVROverlay_IVROverlay_002}, + {"FnTable:IVROverlay_002", &create_winIVROverlay_IVROverlay_002_FnTable, &destroy_winIVROverlay_IVROverlay_002_FnTable}, {"IVRSystem_004", &create_winIVRSystem_IVRSystem_004, &destroy_winIVRSystem_IVRSystem_004}, + {"FnTable:IVRSystem_004", &create_winIVRSystem_IVRSystem_004_FnTable, &destroy_winIVRSystem_IVRSystem_004_FnTable}, {"IVRCompositor_006", &create_winIVRCompositor_IVRCompositor_006, &destroy_winIVRCompositor_IVRCompositor_006}, + {"FnTable:IVRCompositor_006", &create_winIVRCompositor_IVRCompositor_006_FnTable, &destroy_winIVRCompositor_IVRCompositor_006_FnTable}, {"IVROverlay_001", &create_winIVROverlay_IVROverlay_001, &destroy_winIVROverlay_IVROverlay_001}, + {"FnTable:IVROverlay_001", &create_winIVROverlay_IVROverlay_001_FnTable, &destroy_winIVROverlay_IVROverlay_001_FnTable}, {"IVRSystem_003", &create_winIVRSystem_IVRSystem_003, &destroy_winIVRSystem_IVRSystem_003}, + {"FnTable:IVRSystem_003", &create_winIVRSystem_IVRSystem_003_FnTable, &destroy_winIVRSystem_IVRSystem_003_FnTable}, {"IVRCompositor_005", &create_winIVRCompositor_IVRCompositor_005, &destroy_winIVRCompositor_IVRCompositor_005}, + {"FnTable:IVRCompositor_005", &create_winIVRCompositor_IVRCompositor_005_FnTable, &destroy_winIVRCompositor_IVRCompositor_005_FnTable}, diff --git a/vrclient_x64/win_destructors.h b/vrclient_x64/win_destructors.h index 248ee497..5602922b 100644 --- a/vrclient_x64/win_destructors.h +++ b/vrclient_x64/win_destructors.h @@ -1,72 +1,144 @@ extern void destroy_winIVRSystem_IVRSystem_019(void *); +extern void destroy_winIVRSystem_IVRSystem_019_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_006(void *); +extern void destroy_winIVRApplications_IVRApplications_006_FnTable(void *); extern void destroy_winIVRSettings_IVRSettings_002(void *); +extern void destroy_winIVRSettings_IVRSettings_002_FnTable(void *); extern void destroy_winIVRChaperone_IVRChaperone_003(void *); +extern void destroy_winIVRChaperone_IVRChaperone_003_FnTable(void *); extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *); +extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_022(void *); +extern void destroy_winIVRCompositor_IVRCompositor_022_FnTable(void *); extern void destroy_winIVRNotifications_IVRNotifications_002(void *); +extern void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_018(void *); +extern void destroy_winIVROverlay_IVROverlay_018_FnTable(void *); extern void destroy_winIVRRenderModels_IVRRenderModels_005(void *); +extern void destroy_winIVRRenderModels_IVRRenderModels_005_FnTable(void *); extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *); +extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *); extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003(void *); +extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *); extern void destroy_winIVRScreenshots_IVRScreenshots_001(void *); +extern void destroy_winIVRScreenshots_IVRScreenshots_001_FnTable(void *); extern void destroy_winIVRResources_IVRResources_001(void *); +extern void destroy_winIVRResources_IVRResources_001_FnTable(void *); extern void destroy_winIVRDriverManager_IVRDriverManager_001(void *); +extern void destroy_winIVRDriverManager_IVRDriverManager_001_FnTable(void *); extern void destroy_winIVRClientCore_IVRClientCore_003(void *); +extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_017(void *); +extern void destroy_winIVRSystem_IVRSystem_017_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_017(void *); +extern void destroy_winIVROverlay_IVROverlay_017_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_021(void *); +extern void destroy_winIVRCompositor_IVRCompositor_021_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_016(void *); +extern void destroy_winIVROverlay_IVROverlay_016_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_016(void *); +extern void destroy_winIVRSystem_IVRSystem_016_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_020(void *); +extern void destroy_winIVRCompositor_IVRCompositor_020_FnTable(void *); extern void destroy_winIVRClientCore_IVRClientCore_002(void *); +extern void destroy_winIVRClientCore_IVRClientCore_002_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_015(void *); +extern void destroy_winIVRSystem_IVRSystem_015_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_014(void *); +extern void destroy_winIVROverlay_IVROverlay_014_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_019(void *); +extern void destroy_winIVRCompositor_IVRCompositor_019_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_014(void *); +extern void destroy_winIVRSystem_IVRSystem_014_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_018(void *); +extern void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_013(void *); +extern void destroy_winIVROverlay_IVROverlay_013_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_012(void *); +extern void destroy_winIVRSystem_IVRSystem_012_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_016(void *); +extern void destroy_winIVRCompositor_IVRCompositor_016_FnTable(void *); extern void destroy_winIVRSettings_IVRSettings_001(void *); +extern void destroy_winIVRSettings_IVRSettings_001_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_005(void *); +extern void destroy_winIVRApplications_IVRApplications_005_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_015(void *); +extern void destroy_winIVRCompositor_IVRCompositor_015_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_012(void *); +extern void destroy_winIVROverlay_IVROverlay_012_FnTable(void *); extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_002(void *); +extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_002_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_014(void *); +extern void destroy_winIVRCompositor_IVRCompositor_014_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_011(void *); +extern void destroy_winIVROverlay_IVROverlay_011_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_013(void *); +extern void destroy_winIVRCompositor_IVRCompositor_013_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_011(void *); +extern void destroy_winIVRSystem_IVRSystem_011_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_004(void *); +extern void destroy_winIVRApplications_IVRApplications_004_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_010(void *); +extern void destroy_winIVROverlay_IVROverlay_010_FnTable(void *); extern void destroy_winIVRRenderModels_IVRRenderModels_004(void *); +extern void destroy_winIVRRenderModels_IVRRenderModels_004_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_012(void *); +extern void destroy_winIVRCompositor_IVRCompositor_012_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_003(void *); +extern void destroy_winIVRApplications_IVRApplications_003_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_011(void *); +extern void destroy_winIVRCompositor_IVRCompositor_011_FnTable(void *); extern void destroy_winIVRRenderModels_IVRRenderModels_002(void *); +extern void destroy_winIVRRenderModels_IVRRenderModels_002_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_010(void *); +extern void destroy_winIVRSystem_IVRSystem_010_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_002(void *); +extern void destroy_winIVRApplications_IVRApplications_002_FnTable(void *); extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004(void *); +extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_004_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_010(void *); +extern void destroy_winIVRCompositor_IVRCompositor_010_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_008(void *); +extern void destroy_winIVROverlay_IVROverlay_008_FnTable(void *); extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_001(void *); +extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_001_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_009(void *); +extern void destroy_winIVRCompositor_IVRCompositor_009_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_009(void *); +extern void destroy_winIVRSystem_IVRSystem_009_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_007(void *); +extern void destroy_winIVROverlay_IVROverlay_007_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_006(void *); +extern void destroy_winIVRSystem_IVRSystem_006_FnTable(void *); extern void destroy_winIVRApplications_IVRApplications_001(void *); +extern void destroy_winIVRApplications_IVRApplications_001_FnTable(void *); extern void destroy_winIVRChaperone_IVRChaperone_002(void *); +extern void destroy_winIVRChaperone_IVRChaperone_002_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_008(void *); +extern void destroy_winIVRCompositor_IVRCompositor_008_FnTable(void *); extern void destroy_winIVRNotifications_IVRNotifications_001(void *); +extern void destroy_winIVRNotifications_IVRNotifications_001_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_005(void *); +extern void destroy_winIVROverlay_IVROverlay_005_FnTable(void *); extern void destroy_winIVRRenderModels_IVRRenderModels_001(void *); +extern void destroy_winIVRRenderModels_IVRRenderModels_001_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_005(void *); +extern void destroy_winIVRSystem_IVRSystem_005_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_007(void *); +extern void destroy_winIVRCompositor_IVRCompositor_007_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_004(void *); +extern void destroy_winIVROverlay_IVROverlay_004_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_003(void *); +extern void destroy_winIVROverlay_IVROverlay_003_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_002(void *); +extern void destroy_winIVROverlay_IVROverlay_002_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_004(void *); +extern void destroy_winIVRSystem_IVRSystem_004_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_006(void *); +extern void destroy_winIVRCompositor_IVRCompositor_006_FnTable(void *); extern void destroy_winIVROverlay_IVROverlay_001(void *); +extern void destroy_winIVROverlay_IVROverlay_001_FnTable(void *); extern void destroy_winIVRSystem_IVRSystem_003(void *); +extern void destroy_winIVRSystem_IVRSystem_003_FnTable(void *); extern void destroy_winIVRCompositor_IVRCompositor_005(void *); +extern void destroy_winIVRCompositor_IVRCompositor_005_FnTable(void *);