Valve/Proton
1
0
Fork 0
mirror of https://github.com/ValveSoftware/Proton.git synced 2024-12-27 07:05:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

vrclient: Add support for flat (FnTable) API

Browse Source
This commit is contained in:
Zebediah Figura 2018-06-04 10:45:00 -05:00 committed by Andrew Eikum
parent aae498498f
commit f7510f2a7b
22 changed files with 4476 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
vrclient_x64/cxx.h
View File

@ -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__ */

65
vrclient_x64/flatapi.h Normal file
View File

@ -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);
}

32
vrclient_x64/gen_wrapper.py
View File

@ -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))

39
vrclient_x64/vrclient_main.c
View File

@ -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

286
vrclient_x64/winIVRApplications.c
View File

@ -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);
}

67
vrclient_x64/winIVRChaperone.c
View File

@ -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);
}

86
vrclient_x64/winIVRChaperoneSetup.c
View File

@ -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);
}

64
vrclient_x64/winIVRClientCore.c
View File

@ -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);
}

947
vrclient_x64/winIVRCompositor.c
View File

File diff suppressed because it is too large Load Diff

28
vrclient_x64/winIVRDriverManager.c
View File

@ -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);
}

29
vrclient_x64/winIVRExtendedDisplay.c
View File

@ -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);
}

55
vrclient_x64/winIVRNotifications.c
View File

@ -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);
}

1299
vrclient_x64/winIVROverlay.c
View File

File diff suppressed because it is too large Load Diff

146
vrclient_x64/winIVRRenderModels.c
View File

@ -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);
}

28
vrclient_x64/winIVRResources.c
View File

@ -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);
}

33
vrclient_x64/winIVRScreenshots.c
View File

@ -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);
}

74
vrclient_x64/winIVRSettings.c
View File

@ -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);
}

870
vrclient_x64/winIVRSystem.c
View File

@ -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);
}

112
vrclient_x64/winIVRTrackedCamera.c
View File

@ -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);
}

72
vrclient_x64/win_constructors.h
View File

@ -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 *);

72
vrclient_x64/win_constructors_table.dat
View File

@ -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},

72
vrclient_x64/win_destructors.h
View File

@ -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 *);