From f1f483a4437eca8c7408e5b0e66e244162ad7def Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 28 Sep 2023 10:59:50 +0200 Subject: [PATCH] vrclient: Generate struct definitions for all abis. CW-Bug-Id: #22729 --- vrclient_x64/Makefile.in | 1 + vrclient_x64/gen_wrapper.py | 185 +- .../vrclient_x64/unixlib_generated.cpp | 7040 +++++++++++++++++ vrclient_x64/vrclient_x64/vrclient_structs.h | 100 + .../vrclient_x64/vrclient_structs_generated.h | 5734 ++++++++++++++ 5 files changed, 13047 insertions(+), 13 deletions(-) create mode 100644 vrclient_x64/vrclient_x64/unixlib_generated.cpp create mode 100644 vrclient_x64/vrclient_x64/vrclient_structs.h create mode 100644 vrclient_x64/vrclient_x64/vrclient_structs_generated.h diff --git a/vrclient_x64/Makefile.in b/vrclient_x64/Makefile.in index fb4429dc..ce6b1a4a 100644 --- a/vrclient_x64/Makefile.in +++ b/vrclient_x64/Makefile.in @@ -198,3 +198,4 @@ SOURCES = \ vrclient_x64/struct_converters_1715.cpp \ vrclient_x64/struct_converters_1819.cpp \ vrclient_x64/struct_converters_1916.cpp \ + vrclient_x64/unixlib_generated.cpp \ diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py index e7d25fea..d804cf90 100755 --- a/vrclient_x64/gen_wrapper.py +++ b/vrclient_x64/gen_wrapper.py @@ -123,6 +123,7 @@ EXEMPT_STRUCTS = { "HmdVector4_t", "IntersectionMaskCircle_t", "IntersectionMaskRectangle_t", + "CVRSettingHelper", } # structs for which the size is important, either because of arrays or size parameters @@ -356,6 +357,31 @@ class Struct: def fields(self): return [f for f in self.padded_fields if type(f) is not Padding] + def write_definition(self, out, prefix): + version = all_versions[sdkver][self.name] + kind = 'union' if type(self) is Union else 'struct' + wrapped = len(prefix) > 0 + + out(f'#pragma pack( push, {self.align} )\n') + out(f'{kind} {prefix}{version}\n') + out(u'{\n') + for f in self.padded_fields: + if type(f) is Field: + out(f' {declspec(f._cursor, f.name, prefix, wrapped)};\n') + else: + out(f' uint8_t __pad_{f.offset}[{f.size}];\n') + out(u'};\n') + out(u'#pragma pack( pop )\n\n') + + def write_checks(self, out, prefix): + version = all_versions[sdkver][self.name] + + out(f'C_ASSERT( sizeof({prefix}{version}) >= {self.size} );\n') + for f in self.fields: + out(f'C_ASSERT( offsetof({prefix}{version}, {f.name}) == {f.offset} );\n') + out(f'C_ASSERT( sizeof({prefix}{version}().{f.name}) >= {f.size} );\n') + out(u'\n') + def needs_conversion(self, other): if other.id in self._conv_cache: return self._conv_cache[other.id] @@ -380,9 +406,6 @@ class Union(Struct): def __init__(self, sdkver, abi, cursor): super().__init__(sdkver, abi, cursor) - def needs_conversion(self, other): - return False # FIXME - class Method: def __init__(self, sdkver, abi, cursor, index, override): @@ -559,13 +582,13 @@ def callconv(cursor, prefix): def declspec_func(decl, name, prefix): - ret = declspec(decl.get_result(), "", prefix) - params = [declspec(a, "", prefix) for a in decl.argument_types()] + ret = declspec(decl.get_result(), "", prefix, False) + params = [declspec(a, "", prefix, False) for a in decl.argument_types()] params = ", ".join(params) if len(params) else "void" return f'{ret} ({name})({params})' -def declspec(decl, name, prefix): +def declspec(decl, name, prefix, wrapped=False): call = callconv(decl, prefix) if type(decl) is Cursor: decl = decl.type @@ -577,10 +600,16 @@ def declspec(decl, name, prefix): return declspec_func(decl, name, prefix) if decl.kind in (TypeKind.POINTER, TypeKind.LVALUEREFERENCE): decl = decl.get_pointee() - return declspec(decl, f"*{call}{const}{name}", prefix) + spec = declspec(decl, f"*{call}{const}{name}", prefix, False) + if wrapped: + return f'{prefix.upper()}PTR({spec}, {name})' + return spec if decl.kind == TypeKind.CONSTANTARRAY: decl, count = decl.element_type, decl.element_count - return declspec(decl, f"({const}{name})[{count}]", prefix) + if wrapped: + spec = declspec(decl, const, prefix, False) + return f'{prefix.upper()}ARRAY({spec}, {count}, {name})' + return declspec(decl, f"({const}{name})[{count}]", prefix, False) if len(name): name = f' {name}' @@ -595,6 +624,13 @@ def declspec(decl, name, prefix): if type_name.startswith(('IVR', 'ID3D')): return f'{const}void /*{type_name}*/{name}' + if prefix not in (None, "win") and decl.kind == TypeKind.RECORD \ + and type_name in all_versions[sdkver] \ + and type_name not in EXEMPT_STRUCTS: + if type_name in unique_structs: + return f'{const}{all_versions[sdkver][type_name]}{name}' + return f'{const}{prefix}{all_versions[sdkver][type_name]}{name}' + real_name = canonical_typename(decl) real_name = real_name.removeprefix("const ") real_name = real_name.removeprefix("vr::") @@ -682,14 +718,14 @@ def handle_method_cpp(method, classname, cppname, out): type_name = strip_ns(underlying_typename(param)) if param.type.kind != TypeKind.POINTER: - out(f' {declspec(param, f"lin_{name}", "u_").removeprefix("const ")};\n') + out(f' {declspec(param, f"lin_{name}", None).removeprefix("const ")};\n') out(f' win_to_lin_struct_{param.type.spelling}_{display_sdkver(sdkver)}( ¶ms->{name}, &lin_{name} );\n') continue pointee = param.type.get_pointee() if pointee.kind == TypeKind.POINTER: need_output[name] = param - out(f' {declspec(pointee, f"lin_{name}", "u_").removeprefix("const ")};\n') + out(f' {declspec(pointee, f"lin_{name}", None).removeprefix("const ")};\n') continue if type_name in SDK_STRUCTS: @@ -699,7 +735,7 @@ def handle_method_cpp(method, classname, cppname, out): if not pointee.is_const_qualified(): need_output[name] = param - out(f' {declspec(pointee, f"lin_{name}", "u_").removeprefix("const ")};\n') + out(f' {declspec(pointee, f"lin_{name}", None).removeprefix("const ")};\n') out(f' if (params->{name})\n') out(f' struct_{type_name}_{display_sdkver(sdkver)}_win_to_lin( params->{name}, &lin_{name} );\n') @@ -1651,8 +1687,8 @@ for i, name in enumerate(all_structs.keys()): if not versions or sdkver not in versions: continue all_versions[sdkver][name] = versions[sdkver] -def struct_order(tuple): - name, structs = tuple +def struct_order(x): + name, structs = x if type(x) is tuple else (x, all_structs[x]) order = (struct.order for abis in structs.values() for struct in abis.values()) return (min(order), name) @@ -1709,3 +1745,126 @@ with open("tests/main_autogen.c", "a") as f: f.write("}\n") generate_flatapi_c() + + +declared = {} + +with open('vrclient_x64/vrclient_structs_generated.h', 'w') as file: + out = file.write + + for name in sorted(unique_structs, key=struct_order): + if name in EXEMPT_STRUCTS: continue + for sdkver, abis in all_structs[name].items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'struct {version}' in declared: continue + declared[f'struct {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + out(f'typedef {kind} {version} {version};\n') + abis['w64'].write_definition(out, "") + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'typedef {version}' in declared: continue + declared[f'typedef {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + if type(abis['w64']) is Class: + out(f'typedef {kind} u_{version} u_{version};\n') + out(f'typedef {kind} u_{version} u64_{version};\n') + out(f'typedef {kind} u_{version} u32_{version};\n') + out(f'typedef {kind} w_{version} w_{version};\n') + out(f'typedef {kind} w_{version} w64_{version};\n') + out(f'typedef {kind} w_{version} w32_{version};\n') + continue + + if abis["w64"].needs_conversion(abis["u64"]): + out(f'typedef {kind} u64_{version} u64_{version};\n') + else: + out(f'typedef {kind} w64_{version} u64_{version};\n') + out(f'typedef {kind} w64_{version} w64_{version};\n') + + if abis["w32"].needs_conversion(abis["u32"]): + out(f'typedef {kind} u32_{version} u32_{version};\n') + else: + out(f'typedef {kind} w32_{version} u32_{version};\n') + out(f'typedef {kind} w32_{version} w32_{version};\n') + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'struct {version}' in declared: continue + declared[f'struct {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + if type(abis['w64']) is Class: + abis['w64'].write_definition(out, "w_") + abis['u64'].write_definition(out, "u_") + continue + + abis['w64'].write_definition(out, "w64_") + if abis["w64"].needs_conversion(abis["u64"]): + abis['u64'].write_definition(out, "u64_") + + abis['w32'].write_definition(out, "w32_") + if abis["w32"].needs_conversion(abis["u32"]): + abis['u32'].write_definition(out, "u32_") + + out(u'#ifdef __i386__\n') + out(f'typedef w32_{version} w_{version};\n') + out(f'typedef u32_{version} u_{version};\n') + out(u'#endif\n') + out(u'#ifdef __x86_64__\n') + out(f'typedef w64_{version} w_{version};\n') + out(f'typedef u64_{version} u_{version};\n') + out(u'#endif\n') + out(u'\n') + + +with open('vrclient_x64/unixlib_generated.cpp', 'w') as file: + out = file.write + + out(u'/* This file is auto-generated, do not edit. */\n\n') + out(u'#include "vrclient_structs.h"\n\n') + + for name in sorted(unique_structs, key=struct_order): + for sdkver, abis in sorted(all_structs[name].items()): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'checks {version}' in declared: continue + declared[f'checks {version}'] = True + + abis['w64'].write_checks(out, "") + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'checks {version}' in declared: continue + declared[f'checks {version}'] = True + + if type(abis['w64']) is Class: + continue + + abis['w64'].write_checks(out, "w64_") + abis['u64'].write_checks(out, "u64_") + abis['w32'].write_checks(out, "w32_") + abis['u32'].write_checks(out, "u32_") diff --git a/vrclient_x64/vrclient_x64/unixlib_generated.cpp b/vrclient_x64/vrclient_x64/unixlib_generated.cpp new file mode 100644 index 00000000..296772bc --- /dev/null +++ b/vrclient_x64/vrclient_x64/unixlib_generated.cpp @@ -0,0 +1,7040 @@ +/* This file is auto-generated, do not edit. */ + +#include "vrclient_structs.h" + +C_ASSERT( sizeof(VREvent_ApplicationLaunch_t) >= 8 ); +C_ASSERT( offsetof(VREvent_ApplicationLaunch_t, pid) == 0 ); +C_ASSERT( sizeof(VREvent_ApplicationLaunch_t().pid) >= 4 ); +C_ASSERT( offsetof(VREvent_ApplicationLaunch_t, unArgsHandle) == 4 ); +C_ASSERT( sizeof(VREvent_ApplicationLaunch_t().unArgsHandle) >= 4 ); + +C_ASSERT( sizeof(VREvent_Chaperone_t) >= 16 ); +C_ASSERT( offsetof(VREvent_Chaperone_t, m_nPreviousUniverse) == 0 ); +C_ASSERT( sizeof(VREvent_Chaperone_t().m_nPreviousUniverse) >= 8 ); +C_ASSERT( offsetof(VREvent_Chaperone_t, m_nCurrentUniverse) == 8 ); +C_ASSERT( sizeof(VREvent_Chaperone_t().m_nCurrentUniverse) >= 8 ); + +C_ASSERT( sizeof(VREvent_Controller_t) >= 4 ); +C_ASSERT( offsetof(VREvent_Controller_t, button) == 0 ); +C_ASSERT( sizeof(VREvent_Controller_t().button) >= 4 ); + +C_ASSERT( sizeof(VREvent_DualAnalog_t) >= 20 ); +C_ASSERT( offsetof(VREvent_DualAnalog_t, x) == 0 ); +C_ASSERT( sizeof(VREvent_DualAnalog_t().x) >= 4 ); +C_ASSERT( offsetof(VREvent_DualAnalog_t, y) == 4 ); +C_ASSERT( sizeof(VREvent_DualAnalog_t().y) >= 4 ); +C_ASSERT( offsetof(VREvent_DualAnalog_t, transformedX) == 8 ); +C_ASSERT( sizeof(VREvent_DualAnalog_t().transformedX) >= 4 ); +C_ASSERT( offsetof(VREvent_DualAnalog_t, transformedY) == 12 ); +C_ASSERT( sizeof(VREvent_DualAnalog_t().transformedY) >= 4 ); +C_ASSERT( offsetof(VREvent_DualAnalog_t, which) == 16 ); +C_ASSERT( sizeof(VREvent_DualAnalog_t().which) >= 4 ); + +C_ASSERT( sizeof(VREvent_EditingCameraSurface_t) >= 16 ); +C_ASSERT( offsetof(VREvent_EditingCameraSurface_t, overlayHandle) == 0 ); +C_ASSERT( sizeof(VREvent_EditingCameraSurface_t().overlayHandle) >= 8 ); +C_ASSERT( offsetof(VREvent_EditingCameraSurface_t, nVisualMode) == 8 ); +C_ASSERT( sizeof(VREvent_EditingCameraSurface_t().nVisualMode) >= 4 ); + +C_ASSERT( sizeof(VREvent_HDCPError_t) >= 4 ); +C_ASSERT( offsetof(VREvent_HDCPError_t, eCode) == 0 ); +C_ASSERT( sizeof(VREvent_HDCPError_t().eCode) >= 4 ); + +C_ASSERT( sizeof(VREvent_HapticVibration_t) >= 32 ); +C_ASSERT( offsetof(VREvent_HapticVibration_t, containerHandle) == 0 ); +C_ASSERT( sizeof(VREvent_HapticVibration_t().containerHandle) >= 8 ); +C_ASSERT( offsetof(VREvent_HapticVibration_t, componentHandle) == 8 ); +C_ASSERT( sizeof(VREvent_HapticVibration_t().componentHandle) >= 8 ); +C_ASSERT( offsetof(VREvent_HapticVibration_t, fDurationSeconds) == 16 ); +C_ASSERT( sizeof(VREvent_HapticVibration_t().fDurationSeconds) >= 4 ); +C_ASSERT( offsetof(VREvent_HapticVibration_t, fFrequency) == 20 ); +C_ASSERT( sizeof(VREvent_HapticVibration_t().fFrequency) >= 4 ); +C_ASSERT( offsetof(VREvent_HapticVibration_t, fAmplitude) == 24 ); +C_ASSERT( sizeof(VREvent_HapticVibration_t().fAmplitude) >= 4 ); + +C_ASSERT( sizeof(VREvent_InputActionManifestLoad_t) >= 32 ); +C_ASSERT( offsetof(VREvent_InputActionManifestLoad_t, pathAppKey) == 0 ); +C_ASSERT( sizeof(VREvent_InputActionManifestLoad_t().pathAppKey) >= 8 ); +C_ASSERT( offsetof(VREvent_InputActionManifestLoad_t, pathMessage) == 8 ); +C_ASSERT( sizeof(VREvent_InputActionManifestLoad_t().pathMessage) >= 8 ); +C_ASSERT( offsetof(VREvent_InputActionManifestLoad_t, pathMessageParam) == 16 ); +C_ASSERT( sizeof(VREvent_InputActionManifestLoad_t().pathMessageParam) >= 8 ); +C_ASSERT( offsetof(VREvent_InputActionManifestLoad_t, pathManifestPath) == 24 ); +C_ASSERT( sizeof(VREvent_InputActionManifestLoad_t().pathManifestPath) >= 8 ); + +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1015) >= 24 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1015, ulAppContainer) == 0 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1015().ulAppContainer) >= 8 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1015, pathMessage) == 8 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1015().pathMessage) >= 8 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1015, pathUrl) == 16 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1015().pathUrl) >= 8 ); + +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1016) >= 32 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1016, ulAppContainer) == 0 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1016().ulAppContainer) >= 8 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1016, pathMessage) == 8 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1016().pathMessage) >= 8 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1016, pathUrl) == 16 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1016().pathUrl) >= 8 ); +C_ASSERT( offsetof(VREvent_InputBindingLoad_t_1016, pathControllerType) == 24 ); +C_ASSERT( sizeof(VREvent_InputBindingLoad_t_1016().pathControllerType) >= 8 ); + +C_ASSERT( sizeof(VREvent_Ipd_t) >= 4 ); +C_ASSERT( offsetof(VREvent_Ipd_t, ipdMeters) == 0 ); +C_ASSERT( sizeof(VREvent_Ipd_t().ipdMeters) >= 4 ); + +C_ASSERT( sizeof(VREvent_Keyboard_t_0910) >= 16 ); +C_ASSERT( offsetof(VREvent_Keyboard_t_0910, cNewInput) == 0 ); +C_ASSERT( sizeof(VREvent_Keyboard_t_0910().cNewInput) >= 12 ); +C_ASSERT( offsetof(VREvent_Keyboard_t_0910, uFlags) == 12 ); +C_ASSERT( sizeof(VREvent_Keyboard_t_0910().uFlags) >= 4 ); + +C_ASSERT( sizeof(VREvent_Keyboard_t_0912) >= 16 ); +C_ASSERT( offsetof(VREvent_Keyboard_t_0912, cNewInput) == 0 ); +C_ASSERT( sizeof(VREvent_Keyboard_t_0912().cNewInput) >= 8 ); +C_ASSERT( offsetof(VREvent_Keyboard_t_0912, uUserValue) == 8 ); +C_ASSERT( sizeof(VREvent_Keyboard_t_0912().uUserValue) >= 8 ); + +C_ASSERT( sizeof(VREvent_MessageOverlay_t) >= 4 ); +C_ASSERT( offsetof(VREvent_MessageOverlay_t, unVRMessageOverlayResponse) == 0 ); +C_ASSERT( sizeof(VREvent_MessageOverlay_t().unVRMessageOverlayResponse) >= 4 ); + +C_ASSERT( sizeof(VREvent_Mouse_t) >= 12 ); +C_ASSERT( offsetof(VREvent_Mouse_t, x) == 0 ); +C_ASSERT( sizeof(VREvent_Mouse_t().x) >= 4 ); +C_ASSERT( offsetof(VREvent_Mouse_t, y) == 4 ); +C_ASSERT( sizeof(VREvent_Mouse_t().y) >= 4 ); +C_ASSERT( offsetof(VREvent_Mouse_t, button) == 8 ); +C_ASSERT( sizeof(VREvent_Mouse_t().button) >= 4 ); + +C_ASSERT( sizeof(VREvent_Notification_t_092) >= 12 ); +C_ASSERT( offsetof(VREvent_Notification_t_092, x) == 0 ); +C_ASSERT( sizeof(VREvent_Notification_t_092().x) >= 4 ); +C_ASSERT( offsetof(VREvent_Notification_t_092, y) == 4 ); +C_ASSERT( sizeof(VREvent_Notification_t_092().y) >= 4 ); +C_ASSERT( offsetof(VREvent_Notification_t_092, notificationId) == 8 ); +C_ASSERT( sizeof(VREvent_Notification_t_092().notificationId) >= 4 ); + +C_ASSERT( sizeof(VREvent_Notification_t_093) >= 16 ); +C_ASSERT( offsetof(VREvent_Notification_t_093, ulUserValue) == 0 ); +C_ASSERT( sizeof(VREvent_Notification_t_093().ulUserValue) >= 8 ); +C_ASSERT( offsetof(VREvent_Notification_t_093, notificationId) == 8 ); +C_ASSERT( sizeof(VREvent_Notification_t_093().notificationId) >= 4 ); + +C_ASSERT( sizeof(VREvent_Overlay_t_092) >= 8 ); +C_ASSERT( offsetof(VREvent_Overlay_t_092, overlayHandle) == 0 ); +C_ASSERT( sizeof(VREvent_Overlay_t_092().overlayHandle) >= 8 ); + +C_ASSERT( sizeof(VREvent_Overlay_t_1014) >= 16 ); +C_ASSERT( offsetof(VREvent_Overlay_t_1014, overlayHandle) == 0 ); +C_ASSERT( sizeof(VREvent_Overlay_t_1014().overlayHandle) >= 8 ); +C_ASSERT( offsetof(VREvent_Overlay_t_1014, devicePath) == 8 ); +C_ASSERT( sizeof(VREvent_Overlay_t_1014().devicePath) >= 8 ); + +C_ASSERT( sizeof(VREvent_Overlay_t_1168) >= 24 ); +C_ASSERT( offsetof(VREvent_Overlay_t_1168, overlayHandle) == 0 ); +C_ASSERT( sizeof(VREvent_Overlay_t_1168().overlayHandle) >= 8 ); +C_ASSERT( offsetof(VREvent_Overlay_t_1168, devicePath) == 8 ); +C_ASSERT( sizeof(VREvent_Overlay_t_1168().devicePath) >= 8 ); +C_ASSERT( offsetof(VREvent_Overlay_t_1168, memoryBlockId) == 16 ); +C_ASSERT( sizeof(VREvent_Overlay_t_1168().memoryBlockId) >= 8 ); + +C_ASSERT( sizeof(VREvent_PerformanceTest_t) >= 4 ); +C_ASSERT( offsetof(VREvent_PerformanceTest_t, m_nFidelityLevel) == 0 ); +C_ASSERT( sizeof(VREvent_PerformanceTest_t().m_nFidelityLevel) >= 4 ); + +C_ASSERT( sizeof(VREvent_Process_t_090) >= 8 ); +C_ASSERT( offsetof(VREvent_Process_t_090, pid) == 0 ); +C_ASSERT( sizeof(VREvent_Process_t_090().pid) >= 4 ); +C_ASSERT( offsetof(VREvent_Process_t_090, oldPid) == 4 ); +C_ASSERT( sizeof(VREvent_Process_t_090().oldPid) >= 4 ); + +C_ASSERT( sizeof(VREvent_Process_t_0912) >= 12 ); +C_ASSERT( offsetof(VREvent_Process_t_0912, pid) == 0 ); +C_ASSERT( sizeof(VREvent_Process_t_0912().pid) >= 4 ); +C_ASSERT( offsetof(VREvent_Process_t_0912, oldPid) == 4 ); +C_ASSERT( sizeof(VREvent_Process_t_0912().oldPid) >= 4 ); +C_ASSERT( offsetof(VREvent_Process_t_0912, bForced) == 8 ); +C_ASSERT( sizeof(VREvent_Process_t_0912().bForced) >= 1 ); + +C_ASSERT( sizeof(VREvent_Process_t_1210) >= 12 ); +C_ASSERT( offsetof(VREvent_Process_t_1210, pid) == 0 ); +C_ASSERT( sizeof(VREvent_Process_t_1210().pid) >= 4 ); +C_ASSERT( offsetof(VREvent_Process_t_1210, oldPid) == 4 ); +C_ASSERT( sizeof(VREvent_Process_t_1210().oldPid) >= 4 ); +C_ASSERT( offsetof(VREvent_Process_t_1210, bForced) == 8 ); +C_ASSERT( sizeof(VREvent_Process_t_1210().bForced) >= 1 ); +C_ASSERT( offsetof(VREvent_Process_t_1210, bConnectionLost) == 9 ); +C_ASSERT( sizeof(VREvent_Process_t_1210().bConnectionLost) >= 1 ); + +C_ASSERT( sizeof(VREvent_ProgressUpdate_t) >= 48 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, ulApplicationPropertyContainer) == 0 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().ulApplicationPropertyContainer) >= 8 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, pathDevice) == 8 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().pathDevice) >= 8 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, pathInputSource) == 16 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().pathInputSource) >= 8 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, pathProgressAction) == 24 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().pathProgressAction) >= 8 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, pathIcon) == 32 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().pathIcon) >= 8 ); +C_ASSERT( offsetof(VREvent_ProgressUpdate_t, fProgress) == 40 ); +C_ASSERT( sizeof(VREvent_ProgressUpdate_t().fProgress) >= 4 ); + +C_ASSERT( sizeof(VREvent_Property_t) >= 16 ); +C_ASSERT( offsetof(VREvent_Property_t, container) == 0 ); +C_ASSERT( sizeof(VREvent_Property_t().container) >= 8 ); +C_ASSERT( offsetof(VREvent_Property_t, prop) == 8 ); +C_ASSERT( sizeof(VREvent_Property_t().prop) >= 4 ); + +C_ASSERT( sizeof(VREvent_Reserved_t_090) >= 16 ); +C_ASSERT( offsetof(VREvent_Reserved_t_090, reserved0) == 0 ); +C_ASSERT( sizeof(VREvent_Reserved_t_090().reserved0) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_090, reserved1) == 8 ); +C_ASSERT( sizeof(VREvent_Reserved_t_090().reserved1) >= 8 ); + +C_ASSERT( sizeof(VREvent_Reserved_t_1013) >= 32 ); +C_ASSERT( offsetof(VREvent_Reserved_t_1013, reserved0) == 0 ); +C_ASSERT( sizeof(VREvent_Reserved_t_1013().reserved0) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_1013, reserved1) == 8 ); +C_ASSERT( sizeof(VREvent_Reserved_t_1013().reserved1) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_1013, reserved2) == 16 ); +C_ASSERT( sizeof(VREvent_Reserved_t_1013().reserved2) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_1013, reserved3) == 24 ); +C_ASSERT( sizeof(VREvent_Reserved_t_1013().reserved3) >= 8 ); + +C_ASSERT( sizeof(VREvent_Reserved_t_113b) >= 48 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved0) == 0 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved0) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved1) == 8 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved1) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved2) == 16 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved2) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved3) == 24 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved3) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved4) == 32 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved4) >= 8 ); +C_ASSERT( offsetof(VREvent_Reserved_t_113b, reserved5) == 40 ); +C_ASSERT( sizeof(VREvent_Reserved_t_113b().reserved5) >= 8 ); + +C_ASSERT( sizeof(VREvent_ScreenshotProgress_t) >= 4 ); +C_ASSERT( offsetof(VREvent_ScreenshotProgress_t, progress) == 0 ); +C_ASSERT( sizeof(VREvent_ScreenshotProgress_t().progress) >= 4 ); + +C_ASSERT( sizeof(VREvent_Screenshot_t) >= 8 ); +C_ASSERT( offsetof(VREvent_Screenshot_t, handle) == 0 ); +C_ASSERT( sizeof(VREvent_Screenshot_t().handle) >= 4 ); +C_ASSERT( offsetof(VREvent_Screenshot_t, type) == 4 ); +C_ASSERT( sizeof(VREvent_Screenshot_t().type) >= 4 ); + +C_ASSERT( sizeof(VREvent_Scroll_t_0915) >= 12 ); +C_ASSERT( offsetof(VREvent_Scroll_t_0915, xdelta) == 0 ); +C_ASSERT( sizeof(VREvent_Scroll_t_0915().xdelta) >= 4 ); +C_ASSERT( offsetof(VREvent_Scroll_t_0915, ydelta) == 4 ); +C_ASSERT( sizeof(VREvent_Scroll_t_0915().ydelta) >= 4 ); +C_ASSERT( offsetof(VREvent_Scroll_t_0915, repeatCount) == 8 ); +C_ASSERT( sizeof(VREvent_Scroll_t_0915().repeatCount) >= 4 ); + +C_ASSERT( sizeof(VREvent_Scroll_t_1322) >= 16 ); +C_ASSERT( offsetof(VREvent_Scroll_t_1322, xdelta) == 0 ); +C_ASSERT( sizeof(VREvent_Scroll_t_1322().xdelta) >= 4 ); +C_ASSERT( offsetof(VREvent_Scroll_t_1322, ydelta) == 4 ); +C_ASSERT( sizeof(VREvent_Scroll_t_1322().ydelta) >= 4 ); +C_ASSERT( offsetof(VREvent_Scroll_t_1322, unused) == 8 ); +C_ASSERT( sizeof(VREvent_Scroll_t_1322().unused) >= 4 ); +C_ASSERT( offsetof(VREvent_Scroll_t_1322, viewportscale) == 12 ); +C_ASSERT( sizeof(VREvent_Scroll_t_1322().viewportscale) >= 4 ); + +C_ASSERT( sizeof(VREvent_SeatedZeroPoseReset_t) >= 1 ); +C_ASSERT( offsetof(VREvent_SeatedZeroPoseReset_t, bResetBySystemMenu) == 0 ); +C_ASSERT( sizeof(VREvent_SeatedZeroPoseReset_t().bResetBySystemMenu) >= 1 ); + +C_ASSERT( sizeof(VREvent_ShowDevTools_t) >= 4 ); +C_ASSERT( offsetof(VREvent_ShowDevTools_t, nBrowserIdentifier) == 0 ); +C_ASSERT( sizeof(VREvent_ShowDevTools_t().nBrowserIdentifier) >= 4 ); + +C_ASSERT( sizeof(VREvent_ShowUI_t) >= 4 ); +C_ASSERT( offsetof(VREvent_ShowUI_t, eType) == 0 ); +C_ASSERT( sizeof(VREvent_ShowUI_t().eType) >= 4 ); + +C_ASSERT( sizeof(VREvent_SpatialAnchor_t) >= 4 ); +C_ASSERT( offsetof(VREvent_SpatialAnchor_t, unHandle) == 0 ); +C_ASSERT( sizeof(VREvent_SpatialAnchor_t().unHandle) >= 4 ); + +C_ASSERT( sizeof(VREvent_Status_t) >= 4 ); +C_ASSERT( offsetof(VREvent_Status_t, statusState) == 0 ); +C_ASSERT( sizeof(VREvent_Status_t().statusState) >= 4 ); + +C_ASSERT( sizeof(VREvent_TouchPadMove_t) >= 24 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, bFingerDown) == 0 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().bFingerDown) >= 1 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, flSecondsFingerDown) == 4 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().flSecondsFingerDown) >= 4 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, fValueXFirst) == 8 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().fValueXFirst) >= 4 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, fValueYFirst) == 12 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().fValueYFirst) >= 4 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, fValueXRaw) == 16 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().fValueXRaw) >= 4 ); +C_ASSERT( offsetof(VREvent_TouchPadMove_t, fValueYRaw) == 20 ); +C_ASSERT( sizeof(VREvent_TouchPadMove_t().fValueYRaw) >= 4 ); + +C_ASSERT( sizeof(VREvent_WebConsole_t) >= 8 ); +C_ASSERT( offsetof(VREvent_WebConsole_t, webConsoleHandle) == 0 ); +C_ASSERT( sizeof(VREvent_WebConsole_t().webConsoleHandle) >= 8 ); + +C_ASSERT( sizeof(TrackedDevicePose_t) >= 80 ); +C_ASSERT( offsetof(TrackedDevicePose_t, mDeviceToAbsoluteTracking) == 0 ); +C_ASSERT( sizeof(TrackedDevicePose_t().mDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(TrackedDevicePose_t, vVelocity) == 48 ); +C_ASSERT( sizeof(TrackedDevicePose_t().vVelocity) >= 12 ); +C_ASSERT( offsetof(TrackedDevicePose_t, vAngularVelocity) == 60 ); +C_ASSERT( sizeof(TrackedDevicePose_t().vAngularVelocity) >= 12 ); +C_ASSERT( offsetof(TrackedDevicePose_t, eTrackingResult) == 72 ); +C_ASSERT( sizeof(TrackedDevicePose_t().eTrackingResult) >= 4 ); +C_ASSERT( offsetof(TrackedDevicePose_t, bPoseIsValid) == 76 ); +C_ASSERT( sizeof(TrackedDevicePose_t().bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(TrackedDevicePose_t, bDeviceIsConnected) == 77 ); +C_ASSERT( sizeof(TrackedDevicePose_t().bDeviceIsConnected) >= 1 ); + +C_ASSERT( sizeof(VREvent_Data_t_090) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_090, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_090().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_090, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_090().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_090, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_090().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_090, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_090().process) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_092) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_092, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_092, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_092, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_092, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().process) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_092, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().notification) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_092, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_092().overlay) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_093) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_093, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_093, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_093, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_093, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().process) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_093, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_093, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_093().overlay) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_0910) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().process) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0910, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0910().keyboard) >= 16 ); + +C_ASSERT( sizeof(VREvent_Data_t_0912) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0912, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0912().chaperone) >= 16 ); + +C_ASSERT( sizeof(VREvent_Data_t_0914) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0914, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0914().performanceTest) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_0915) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0915, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0915().touchPadMove) >= 24 ); + +C_ASSERT( sizeof(VREvent_Data_t_0918) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_0918, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_0918().seatedZeroPoseReset) >= 1 ); + +C_ASSERT( sizeof(VREvent_Data_t_097) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_097, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_097, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_097, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_097, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().process) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_097, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_097, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_097, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_097().status) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_101) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_101, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_101, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_101, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_101, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_101, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_101, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_101, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_101, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_101, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_101, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_101, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_101, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_101, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_101, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_101, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_101().screenshot) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_106) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_106, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_106, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_106, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_106, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_106, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_106, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_106, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_106, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_106, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_106, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_106, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_106, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_106, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_106, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_106, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_106().property) >= 16 ); + +C_ASSERT( sizeof(VREvent_Data_t_1011) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1011, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1011().dualAnalog) >= 20 ); + +C_ASSERT( sizeof(VREvent_Data_t_1012) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1012, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1012().hapticVibration) >= 32 ); + +C_ASSERT( sizeof(VREvent_Data_t_1013) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().reserved) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1013, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1013().hapticVibration) >= 32 ); + +C_ASSERT( sizeof(VREvent_Data_t_1014) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().reserved) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1014, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1014().webConsole) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_1015) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().reserved) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1015, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1015().inputBinding) >= 24 ); + +C_ASSERT( sizeof(VREvent_Data_t_1016) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().reserved) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1016, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1016().spatialAnchor) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_102) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_102, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_102, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_102, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_102, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_102, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_102, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_102, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_102, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_102, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_102, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_102, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_102, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_102, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_102, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_102, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_102, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_102, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_102().applicationLaunch) >= 8 ); + +C_ASSERT( sizeof(VREvent_Data_t_103) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_103, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_103, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_103, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_103, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_103, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_103, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_103, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_103, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_103, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_103, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_103, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_103, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_103, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_103, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_103, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_103, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_103, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_103, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_103().cameraSurface) >= 16 ); + +C_ASSERT( sizeof(VREvent_Data_t_105) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_105, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().reserved) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_105, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_105, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_105, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_105, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_105, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_105, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().overlay) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_105, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_105, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_105, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_105, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_105, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_105, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_105, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_105, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_105, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_105, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_105, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_105, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_105().messageOverlay) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_113b) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().reserved) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().spatialAnchor) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, progressUpdate) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().progressUpdate) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_113b, showUi) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_113b().showUi) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_11030) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().reserved) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().scroll) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().spatialAnchor) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, progressUpdate) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().progressUpdate) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, showUi) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().showUi) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, showDevTools) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().showDevTools) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_11030, hdcpError) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_11030().hdcpError) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_1168) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().reserved) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().scroll) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().overlay) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().spatialAnchor) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, progressUpdate) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().progressUpdate) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, showUi) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().showUi) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, showDevTools) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().showDevTools) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1168, hdcpError) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1168().hdcpError) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_1210) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().reserved) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().scroll) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().spatialAnchor) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, progressUpdate) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().progressUpdate) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1210, showUi) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1210().showUi) >= 4 ); + +C_ASSERT( sizeof(VREvent_Data_t_1322) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, reserved) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().reserved) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, controller) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().controller) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, mouse) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().mouse) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, scroll) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().scroll) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, process) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().process) >= 12 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, notification) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().notification) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, overlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().overlay) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, status) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().status) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, keyboard) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().keyboard) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, ipd) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().ipd) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, chaperone) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().chaperone) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, performanceTest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().performanceTest) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, touchPadMove) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().touchPadMove) >= 24 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, seatedZeroPoseReset) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().seatedZeroPoseReset) >= 1 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, screenshot) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().screenshot) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, screenshotProgress) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().screenshotProgress) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, applicationLaunch) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().applicationLaunch) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, cameraSurface) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().cameraSurface) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, messageOverlay) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().messageOverlay) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, property) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().property) >= 16 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, dualAnalog) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().dualAnalog) >= 20 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, hapticVibration) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().hapticVibration) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, webConsole) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().webConsole) >= 8 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, inputBinding) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().inputBinding) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, actionManifest) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().actionManifest) >= 32 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, spatialAnchor) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().spatialAnchor) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, progressUpdate) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().progressUpdate) >= 48 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, showUi) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().showUi) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, showDevTools) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().showDevTools) >= 4 ); +C_ASSERT( offsetof(VREvent_Data_t_1322, hdcpError) == 0 ); +C_ASSERT( sizeof(VREvent_Data_t_1322().hdcpError) >= 4 ); + +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_Data_t) >= 16 ); +C_ASSERT( offsetof(VROverlayIntersectionMaskPrimitive_Data_t, m_Rectangle) == 0 ); +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_Data_t().m_Rectangle) >= 16 ); +C_ASSERT( offsetof(VROverlayIntersectionMaskPrimitive_Data_t, m_Circle) == 0 ); +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_Data_t().m_Circle) >= 12 ); + +C_ASSERT( sizeof(VRTextureBounds_t) >= 16 ); +C_ASSERT( offsetof(VRTextureBounds_t, uMin) == 0 ); +C_ASSERT( sizeof(VRTextureBounds_t().uMin) >= 4 ); +C_ASSERT( offsetof(VRTextureBounds_t, vMin) == 4 ); +C_ASSERT( sizeof(VRTextureBounds_t().vMin) >= 4 ); +C_ASSERT( offsetof(VRTextureBounds_t, uMax) == 8 ); +C_ASSERT( sizeof(VRTextureBounds_t().uMax) >= 4 ); +C_ASSERT( offsetof(VRTextureBounds_t, vMax) == 12 ); +C_ASSERT( sizeof(VRTextureBounds_t().vMax) >= 4 ); + +C_ASSERT( sizeof(ChaperoneSeatedBoundsInfo_t) >= 36 ); +C_ASSERT( offsetof(ChaperoneSeatedBoundsInfo_t, vSeatedHeadPosition) == 0 ); +C_ASSERT( sizeof(ChaperoneSeatedBoundsInfo_t().vSeatedHeadPosition) >= 12 ); +C_ASSERT( offsetof(ChaperoneSeatedBoundsInfo_t, vDeskEdgePositions) == 12 ); +C_ASSERT( sizeof(ChaperoneSeatedBoundsInfo_t().vDeskEdgePositions) >= 24 ); + +C_ASSERT( sizeof(ChaperoneSoftBoundsInfo_t) >= 48 ); +C_ASSERT( offsetof(ChaperoneSoftBoundsInfo_t, quadCorners) == 0 ); +C_ASSERT( sizeof(ChaperoneSoftBoundsInfo_t().quadCorners) >= 48 ); + +C_ASSERT( sizeof(Compositor_BenchmarkResults) >= 8 ); +C_ASSERT( offsetof(Compositor_BenchmarkResults, m_flMegaPixelsPerSecond) == 0 ); +C_ASSERT( sizeof(Compositor_BenchmarkResults().m_flMegaPixelsPerSecond) >= 4 ); +C_ASSERT( offsetof(Compositor_BenchmarkResults, m_flHmdRecommendedMegaPixelsPerSecond) == 4 ); +C_ASSERT( sizeof(Compositor_BenchmarkResults().m_flHmdRecommendedMegaPixelsPerSecond) >= 4 ); + +C_ASSERT( sizeof(Compositor_CumulativeStats_100) >= 60 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nPid) == 0 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nPid) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumFramePresents) == 4 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumDroppedFrames) == 8 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumReprojectedFrames) == 12 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumReprojectedFrames) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumFramePresentsOnStartup) == 16 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumFramePresentsOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumDroppedFramesOnStartup) == 20 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumDroppedFramesOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumReprojectedFramesOnStartup) == 24 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumReprojectedFramesOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumLoading) == 28 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumFramePresentsLoading) == 32 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumFramePresentsLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumDroppedFramesLoading) == 36 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumDroppedFramesLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumReprojectedFramesLoading) == 40 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumReprojectedFramesLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumTimedOut) == 44 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumFramePresentsTimedOut) == 48 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumFramePresentsTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumDroppedFramesTimedOut) == 52 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumDroppedFramesTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_100, m_nNumReprojectedFramesTimedOut) == 56 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_100().m_nNumReprojectedFramesTimedOut) >= 4 ); + +C_ASSERT( sizeof(Compositor_CumulativeStats_1267) >= 112 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nPid) == 0 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nPid) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFramePresents) == 4 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumDroppedFrames) == 8 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumReprojectedFrames) == 12 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumReprojectedFrames) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFramePresentsOnStartup) == 16 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFramePresentsOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumDroppedFramesOnStartup) == 20 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumDroppedFramesOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumReprojectedFramesOnStartup) == 24 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumReprojectedFramesOnStartup) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumLoading) == 28 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFramePresentsLoading) == 32 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFramePresentsLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumDroppedFramesLoading) == 36 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumDroppedFramesLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumReprojectedFramesLoading) == 40 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumReprojectedFramesLoading) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumTimedOut) == 44 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFramePresentsTimedOut) == 48 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFramePresentsTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumDroppedFramesTimedOut) == 52 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumDroppedFramesTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumReprojectedFramesTimedOut) == 56 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumReprojectedFramesTimedOut) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFrameSubmits) == 60 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFrameSubmits) >= 4 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_flSumCompositorCPUTimeMS) == 64 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_flSumCompositorCPUTimeMS) >= 8 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_flSumCompositorGPUTimeMS) == 72 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_flSumCompositorGPUTimeMS) >= 8 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_flSumTargetFrameTimes) == 80 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_flSumTargetFrameTimes) >= 8 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_flSumApplicationCPUTimeMS) == 88 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_flSumApplicationCPUTimeMS) >= 8 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_flSumApplicationGPUTimeMS) == 96 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_flSumApplicationGPUTimeMS) >= 8 ); +C_ASSERT( offsetof(Compositor_CumulativeStats_1267, m_nNumFramesWithDepth) == 104 ); +C_ASSERT( sizeof(Compositor_CumulativeStats_1267().m_nNumFramesWithDepth) >= 4 ); + +C_ASSERT( sizeof(Compositor_OverlaySettings) >= 112 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, size) == 0 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().size) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, curved) == 4 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().curved) >= 1 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, antialias) == 5 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().antialias) >= 1 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, scale) == 8 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().scale) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, distance) == 12 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().distance) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, alpha) == 16 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().alpha) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, uOffset) == 20 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().uOffset) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, vOffset) == 24 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().vOffset) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, uScale) == 28 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().uScale) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, vScale) == 32 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().vScale) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, gridDivs) == 36 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().gridDivs) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, gridWidth) == 40 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().gridWidth) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, gridScale) == 44 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().gridScale) >= 4 ); +C_ASSERT( offsetof(Compositor_OverlaySettings, transform) == 48 ); +C_ASSERT( sizeof(Compositor_OverlaySettings().transform) >= 64 ); + +C_ASSERT( sizeof(Compositor_StageRenderSettings) >= 48 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_PrimaryColor) == 0 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_PrimaryColor) >= 16 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_SecondaryColor) == 16 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_SecondaryColor) >= 16 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_flVignetteInnerRadius) == 32 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_flVignetteInnerRadius) >= 4 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_flVignetteOuterRadius) == 36 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_flVignetteOuterRadius) >= 4 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_flFresnelStrength) == 40 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_flFresnelStrength) >= 4 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_bBackfaceCulling) == 44 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_bBackfaceCulling) >= 1 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_bGreyscale) == 45 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_bGreyscale) >= 1 ); +C_ASSERT( offsetof(Compositor_StageRenderSettings, m_bWireframe) == 46 ); +C_ASSERT( sizeof(Compositor_StageRenderSettings().m_bWireframe) >= 1 ); + +C_ASSERT( sizeof(Compositor_TextureBounds) >= 16 ); +C_ASSERT( offsetof(Compositor_TextureBounds, uMin) == 0 ); +C_ASSERT( sizeof(Compositor_TextureBounds().uMin) >= 4 ); +C_ASSERT( offsetof(Compositor_TextureBounds, vMin) == 4 ); +C_ASSERT( sizeof(Compositor_TextureBounds().vMin) >= 4 ); +C_ASSERT( offsetof(Compositor_TextureBounds, uMax) == 8 ); +C_ASSERT( sizeof(Compositor_TextureBounds().uMax) >= 4 ); +C_ASSERT( offsetof(Compositor_TextureBounds, vMax) == 12 ); +C_ASSERT( sizeof(Compositor_TextureBounds().vMax) >= 4 ); + +C_ASSERT( sizeof(DistortionCoordinates_t) >= 24 ); +C_ASSERT( offsetof(DistortionCoordinates_t, rfRed) == 0 ); +C_ASSERT( sizeof(DistortionCoordinates_t().rfRed) >= 8 ); +C_ASSERT( offsetof(DistortionCoordinates_t, rfGreen) == 8 ); +C_ASSERT( sizeof(DistortionCoordinates_t().rfGreen) >= 8 ); +C_ASSERT( offsetof(DistortionCoordinates_t, rfBlue) == 16 ); +C_ASSERT( sizeof(DistortionCoordinates_t().rfBlue) >= 8 ); + +C_ASSERT( sizeof(DriverDirectMode_FrameTiming) >= 20 ); +C_ASSERT( offsetof(DriverDirectMode_FrameTiming, m_nSize) == 0 ); +C_ASSERT( sizeof(DriverDirectMode_FrameTiming().m_nSize) >= 4 ); +C_ASSERT( offsetof(DriverDirectMode_FrameTiming, m_nNumFramePresents) == 4 ); +C_ASSERT( sizeof(DriverDirectMode_FrameTiming().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(DriverDirectMode_FrameTiming, m_nNumMisPresented) == 8 ); +C_ASSERT( sizeof(DriverDirectMode_FrameTiming().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(DriverDirectMode_FrameTiming, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(DriverDirectMode_FrameTiming().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(DriverDirectMode_FrameTiming, m_nReprojectionFlags) == 16 ); +C_ASSERT( sizeof(DriverDirectMode_FrameTiming().m_nReprojectionFlags) >= 4 ); + +C_ASSERT( sizeof(HmdRect2_t) >= 16 ); +C_ASSERT( offsetof(HmdRect2_t, vTopLeft) == 0 ); +C_ASSERT( sizeof(HmdRect2_t().vTopLeft) >= 8 ); +C_ASSERT( offsetof(HmdRect2_t, vBottomRight) == 8 ); +C_ASSERT( sizeof(HmdRect2_t().vBottomRight) >= 8 ); + +C_ASSERT( sizeof(ImuSample_t) >= 64 ); +C_ASSERT( offsetof(ImuSample_t, fSampleTime) == 0 ); +C_ASSERT( sizeof(ImuSample_t().fSampleTime) >= 8 ); +C_ASSERT( offsetof(ImuSample_t, vAccel) == 8 ); +C_ASSERT( sizeof(ImuSample_t().vAccel) >= 24 ); +C_ASSERT( offsetof(ImuSample_t, vGyro) == 32 ); +C_ASSERT( sizeof(ImuSample_t().vGyro) >= 24 ); +C_ASSERT( offsetof(ImuSample_t, unOffScaleFlags) == 56 ); +C_ASSERT( sizeof(ImuSample_t().unOffScaleFlags) >= 4 ); + +C_ASSERT( sizeof(InputBindingInfo_t_11030) >= 544 ); +C_ASSERT( offsetof(InputBindingInfo_t_11030, rchDevicePathName) == 0 ); +C_ASSERT( sizeof(InputBindingInfo_t_11030().rchDevicePathName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_11030, rchInputPathName) == 128 ); +C_ASSERT( sizeof(InputBindingInfo_t_11030().rchInputPathName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_11030, rchModeName) == 256 ); +C_ASSERT( sizeof(InputBindingInfo_t_11030().rchModeName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_11030, rchSlotName) == 384 ); +C_ASSERT( sizeof(InputBindingInfo_t_11030().rchSlotName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_11030, rchInputSourceType) == 512 ); +C_ASSERT( sizeof(InputBindingInfo_t_11030().rchInputSourceType) >= 32 ); + +C_ASSERT( sizeof(InputBindingInfo_t_1517) >= 512 ); +C_ASSERT( offsetof(InputBindingInfo_t_1517, rchDevicePathName) == 0 ); +C_ASSERT( sizeof(InputBindingInfo_t_1517().rchDevicePathName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_1517, rchInputPathName) == 128 ); +C_ASSERT( sizeof(InputBindingInfo_t_1517().rchInputPathName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_1517, rchModeName) == 256 ); +C_ASSERT( sizeof(InputBindingInfo_t_1517().rchModeName) >= 128 ); +C_ASSERT( offsetof(InputBindingInfo_t_1517, rchSlotName) == 384 ); +C_ASSERT( sizeof(InputBindingInfo_t_1517().rchSlotName) >= 128 ); + +C_ASSERT( sizeof(NotificationItem) >= 4 ); +C_ASSERT( offsetof(NotificationItem, notificationId) == 0 ); +C_ASSERT( sizeof(NotificationItem().notificationId) >= 4 ); + +C_ASSERT( sizeof(RenderModel_ComponentState_t) >= 100 ); +C_ASSERT( offsetof(RenderModel_ComponentState_t, mTrackingToComponentRenderModel) == 0 ); +C_ASSERT( sizeof(RenderModel_ComponentState_t().mTrackingToComponentRenderModel) >= 48 ); +C_ASSERT( offsetof(RenderModel_ComponentState_t, mTrackingToComponentLocal) == 48 ); +C_ASSERT( sizeof(RenderModel_ComponentState_t().mTrackingToComponentLocal) >= 48 ); +C_ASSERT( offsetof(RenderModel_ComponentState_t, uProperties) == 96 ); +C_ASSERT( sizeof(RenderModel_ComponentState_t().uProperties) >= 4 ); + +C_ASSERT( sizeof(RenderModel_ControllerMode_State_t) >= 1 ); +C_ASSERT( offsetof(RenderModel_ControllerMode_State_t, bScrollWheelVisible) == 0 ); +C_ASSERT( sizeof(RenderModel_ControllerMode_State_t().bScrollWheelVisible) >= 1 ); + +C_ASSERT( sizeof(RenderModel_Vertex_t) >= 32 ); +C_ASSERT( offsetof(RenderModel_Vertex_t, vPosition) == 0 ); +C_ASSERT( sizeof(RenderModel_Vertex_t().vPosition) >= 12 ); +C_ASSERT( offsetof(RenderModel_Vertex_t, vNormal) == 12 ); +C_ASSERT( sizeof(RenderModel_Vertex_t().vNormal) >= 12 ); +C_ASSERT( offsetof(RenderModel_Vertex_t, rfTextureCoord) == 24 ); +C_ASSERT( sizeof(RenderModel_Vertex_t().rfTextureCoord) >= 8 ); + +C_ASSERT( sizeof(SpatialAnchorPose_t) >= 48 ); +C_ASSERT( offsetof(SpatialAnchorPose_t, mAnchorToAbsoluteTracking) == 0 ); +C_ASSERT( sizeof(SpatialAnchorPose_t().mAnchorToAbsoluteTracking) >= 48 ); + +C_ASSERT( sizeof(VRActiveActionSet_t_1015) >= 24 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1015, ulActionSet) == 0 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1015().ulActionSet) >= 8 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1015, ulRestrictedToDevice) == 8 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1015().ulRestrictedToDevice) >= 8 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1015, ulSecondaryActionSet) == 16 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1015().ulSecondaryActionSet) >= 8 ); + +C_ASSERT( sizeof(VRActiveActionSet_t_1016) >= 32 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1016, ulActionSet) == 0 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1016().ulActionSet) >= 8 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1016, ulRestrictedToDevice) == 8 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1016().ulRestrictedToDevice) >= 8 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1016, ulSecondaryActionSet) == 16 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1016().ulSecondaryActionSet) >= 8 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1016, unPadding) == 24 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1016().unPadding) >= 4 ); +C_ASSERT( offsetof(VRActiveActionSet_t_1016, nPriority) == 28 ); +C_ASSERT( sizeof(VRActiveActionSet_t_1016().nPriority) >= 4 ); + +C_ASSERT( sizeof(VRBoneTransform_t) >= 32 ); +C_ASSERT( offsetof(VRBoneTransform_t, position) == 0 ); +C_ASSERT( sizeof(VRBoneTransform_t().position) >= 16 ); +C_ASSERT( offsetof(VRBoneTransform_t, orientation) == 16 ); +C_ASSERT( sizeof(VRBoneTransform_t().orientation) >= 16 ); + +C_ASSERT( sizeof(VRControllerAxis_t) >= 8 ); +C_ASSERT( offsetof(VRControllerAxis_t, x) == 0 ); +C_ASSERT( sizeof(VRControllerAxis_t().x) >= 4 ); +C_ASSERT( offsetof(VRControllerAxis_t, y) == 4 ); +C_ASSERT( sizeof(VRControllerAxis_t().y) >= 4 ); + +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_t) >= 20 ); +C_ASSERT( offsetof(VROverlayIntersectionMaskPrimitive_t, m_nPrimitiveType) == 0 ); +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_t().m_nPrimitiveType) >= 4 ); +C_ASSERT( offsetof(VROverlayIntersectionMaskPrimitive_t, m_Primitive) == 4 ); +C_ASSERT( sizeof(VROverlayIntersectionMaskPrimitive_t().m_Primitive) >= 16 ); + +C_ASSERT( sizeof(VROverlayIntersectionParams_t) >= 28 ); +C_ASSERT( offsetof(VROverlayIntersectionParams_t, vSource) == 0 ); +C_ASSERT( sizeof(VROverlayIntersectionParams_t().vSource) >= 12 ); +C_ASSERT( offsetof(VROverlayIntersectionParams_t, vDirection) == 12 ); +C_ASSERT( sizeof(VROverlayIntersectionParams_t().vDirection) >= 12 ); +C_ASSERT( offsetof(VROverlayIntersectionParams_t, eOrigin) == 24 ); +C_ASSERT( sizeof(VROverlayIntersectionParams_t().eOrigin) >= 4 ); + +C_ASSERT( sizeof(VROverlayIntersectionResults_t) >= 36 ); +C_ASSERT( offsetof(VROverlayIntersectionResults_t, vPoint) == 0 ); +C_ASSERT( sizeof(VROverlayIntersectionResults_t().vPoint) >= 12 ); +C_ASSERT( offsetof(VROverlayIntersectionResults_t, vNormal) == 12 ); +C_ASSERT( sizeof(VROverlayIntersectionResults_t().vNormal) >= 12 ); +C_ASSERT( offsetof(VROverlayIntersectionResults_t, vUVs) == 24 ); +C_ASSERT( sizeof(VROverlayIntersectionResults_t().vUVs) >= 8 ); +C_ASSERT( offsetof(VROverlayIntersectionResults_t, fDistance) == 32 ); +C_ASSERT( sizeof(VROverlayIntersectionResults_t().fDistance) >= 4 ); + +C_ASSERT( sizeof(VROverlayProjection_t) >= 16 ); +C_ASSERT( offsetof(VROverlayProjection_t, fLeft) == 0 ); +C_ASSERT( sizeof(VROverlayProjection_t().fLeft) >= 4 ); +C_ASSERT( offsetof(VROverlayProjection_t, fRight) == 4 ); +C_ASSERT( sizeof(VROverlayProjection_t().fRight) >= 4 ); +C_ASSERT( offsetof(VROverlayProjection_t, fTop) == 8 ); +C_ASSERT( sizeof(VROverlayProjection_t().fTop) >= 4 ); +C_ASSERT( offsetof(VROverlayProjection_t, fBottom) == 12 ); +C_ASSERT( sizeof(VROverlayProjection_t().fBottom) >= 4 ); + +C_ASSERT( sizeof(VRSkeletalSummaryData_t) >= 36 ); +C_ASSERT( offsetof(VRSkeletalSummaryData_t, flFingerCurl) == 0 ); +C_ASSERT( sizeof(VRSkeletalSummaryData_t().flFingerCurl) >= 20 ); +C_ASSERT( offsetof(VRSkeletalSummaryData_t, flFingerSplay) == 20 ); +C_ASSERT( sizeof(VRSkeletalSummaryData_t().flFingerSplay) >= 16 ); + +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237) >= 24 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_1237, unWidth) == 0 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237().unWidth) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_1237, unHeight) == 2 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237().unHeight) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_1237, rubTextureMapData) == 8 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237().rubTextureMapData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_1237, format) == 16 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237().format) >= 4 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_1237, unMipLevels) == 20 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_1237().unMipLevels) >= 2 ); + +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237) >= 20 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_1237, unWidth) == 0 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237().unWidth) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_1237, unHeight) == 2 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237().unHeight) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_1237, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237().rubTextureMapData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_1237, format) == 12 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237().format) >= 4 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_1237, unMipLevels) == 16 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_1237().unMipLevels) >= 2 ); + +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237) >= 16 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_1237, unWidth) == 0 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237().unWidth) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_1237, unHeight) == 2 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237().unHeight) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_1237, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237().rubTextureMapData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_1237, format) == 8 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237().format) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_1237, unMipLevels) == 12 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_1237().unMipLevels) >= 2 ); + +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237) >= 16 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_1237, unWidth) == 0 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237().unWidth) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_1237, unHeight) == 2 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237().unHeight) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_1237, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237().rubTextureMapData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_1237, format) == 8 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237().format) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_1237, unMipLevels) == 12 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_1237().unMipLevels) >= 2 ); + +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_11111) >= 24 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_11111, unWidth) == 0 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_11111().unWidth) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_11111, unHeight) == 2 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_11111().unHeight) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_11111, rubTextureMapData) == 8 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_11111().rubTextureMapData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_11111, format) == 16 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_11111().format) >= 4 ); + +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_11111) >= 16 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_11111, unWidth) == 0 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_11111().unWidth) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_11111, unHeight) == 2 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_11111().unHeight) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_11111, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_11111().rubTextureMapData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_11111, format) == 12 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_11111().format) >= 4 ); + +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_11111) >= 12 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_11111, unWidth) == 0 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_11111().unWidth) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_11111, unHeight) == 2 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_11111().unHeight) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_11111, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_11111().rubTextureMapData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_11111, format) == 8 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_11111().format) >= 4 ); + +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_11111) >= 12 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_11111, unWidth) == 0 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_11111().unWidth) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_11111, unHeight) == 2 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_11111().unHeight) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_11111, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_11111().rubTextureMapData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_11111, format) == 8 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_11111().format) >= 4 ); + +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_090) >= 16 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_090, unWidth) == 0 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_090().unWidth) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_090, unHeight) == 2 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_090().unHeight) >= 2 ); +C_ASSERT( offsetof(w64_RenderModel_TextureMap_t_090, rubTextureMapData) == 8 ); +C_ASSERT( sizeof(w64_RenderModel_TextureMap_t_090().rubTextureMapData) >= 8 ); + +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_090) >= 12 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_090, unWidth) == 0 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_090().unWidth) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_090, unHeight) == 2 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_090().unHeight) >= 2 ); +C_ASSERT( offsetof(u64_RenderModel_TextureMap_t_090, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u64_RenderModel_TextureMap_t_090().rubTextureMapData) >= 8 ); + +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_090) >= 8 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_090, unWidth) == 0 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_090().unWidth) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_090, unHeight) == 2 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_090().unHeight) >= 2 ); +C_ASSERT( offsetof(w32_RenderModel_TextureMap_t_090, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(w32_RenderModel_TextureMap_t_090().rubTextureMapData) >= 4 ); + +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_090) >= 8 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_090, unWidth) == 0 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_090().unWidth) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_090, unHeight) == 2 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_090().unHeight) >= 2 ); +C_ASSERT( offsetof(u32_RenderModel_TextureMap_t_090, rubTextureMapData) == 4 ); +C_ASSERT( sizeof(u32_RenderModel_TextureMap_t_090().rubTextureMapData) >= 4 ); + +C_ASSERT( sizeof(w64_Texture_t) >= 16 ); +C_ASSERT( offsetof(w64_Texture_t, handle) == 0 ); +C_ASSERT( sizeof(w64_Texture_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_Texture_t, eType) == 8 ); +C_ASSERT( sizeof(w64_Texture_t().eType) >= 4 ); +C_ASSERT( offsetof(w64_Texture_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(w64_Texture_t().eColorSpace) >= 4 ); + +C_ASSERT( sizeof(u64_Texture_t) >= 16 ); +C_ASSERT( offsetof(u64_Texture_t, handle) == 0 ); +C_ASSERT( sizeof(u64_Texture_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_Texture_t, eType) == 8 ); +C_ASSERT( sizeof(u64_Texture_t().eType) >= 4 ); +C_ASSERT( offsetof(u64_Texture_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(u64_Texture_t().eColorSpace) >= 4 ); + +C_ASSERT( sizeof(w32_Texture_t) >= 12 ); +C_ASSERT( offsetof(w32_Texture_t, handle) == 0 ); +C_ASSERT( sizeof(w32_Texture_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_Texture_t, eType) == 4 ); +C_ASSERT( sizeof(w32_Texture_t().eType) >= 4 ); +C_ASSERT( offsetof(w32_Texture_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(w32_Texture_t().eColorSpace) >= 4 ); + +C_ASSERT( sizeof(u32_Texture_t) >= 12 ); +C_ASSERT( offsetof(u32_Texture_t, handle) == 0 ); +C_ASSERT( sizeof(u32_Texture_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_Texture_t, eType) == 4 ); +C_ASSERT( sizeof(u32_Texture_t().eType) >= 4 ); +C_ASSERT( offsetof(u32_Texture_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(u32_Texture_t().eColorSpace) >= 4 ); + +C_ASSERT( sizeof(w64_VRTextureDepthInfo_t) >= 80 ); +C_ASSERT( offsetof(w64_VRTextureDepthInfo_t, handle) == 0 ); +C_ASSERT( sizeof(w64_VRTextureDepthInfo_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_VRTextureDepthInfo_t, mProjection) == 8 ); +C_ASSERT( sizeof(w64_VRTextureDepthInfo_t().mProjection) >= 64 ); +C_ASSERT( offsetof(w64_VRTextureDepthInfo_t, vRange) == 72 ); +C_ASSERT( sizeof(w64_VRTextureDepthInfo_t().vRange) >= 8 ); + +C_ASSERT( sizeof(u64_VRTextureDepthInfo_t) >= 80 ); +C_ASSERT( offsetof(u64_VRTextureDepthInfo_t, handle) == 0 ); +C_ASSERT( sizeof(u64_VRTextureDepthInfo_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_VRTextureDepthInfo_t, mProjection) == 8 ); +C_ASSERT( sizeof(u64_VRTextureDepthInfo_t().mProjection) >= 64 ); +C_ASSERT( offsetof(u64_VRTextureDepthInfo_t, vRange) == 72 ); +C_ASSERT( sizeof(u64_VRTextureDepthInfo_t().vRange) >= 8 ); + +C_ASSERT( sizeof(w32_VRTextureDepthInfo_t) >= 76 ); +C_ASSERT( offsetof(w32_VRTextureDepthInfo_t, handle) == 0 ); +C_ASSERT( sizeof(w32_VRTextureDepthInfo_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureDepthInfo_t, mProjection) == 4 ); +C_ASSERT( sizeof(w32_VRTextureDepthInfo_t().mProjection) >= 64 ); +C_ASSERT( offsetof(w32_VRTextureDepthInfo_t, vRange) == 68 ); +C_ASSERT( sizeof(w32_VRTextureDepthInfo_t().vRange) >= 8 ); + +C_ASSERT( sizeof(u32_VRTextureDepthInfo_t) >= 76 ); +C_ASSERT( offsetof(u32_VRTextureDepthInfo_t, handle) == 0 ); +C_ASSERT( sizeof(u32_VRTextureDepthInfo_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureDepthInfo_t, mProjection) == 4 ); +C_ASSERT( sizeof(u32_VRTextureDepthInfo_t().mProjection) >= 64 ); +C_ASSERT( offsetof(u32_VRTextureDepthInfo_t, vRange) == 68 ); +C_ASSERT( sizeof(u32_VRTextureDepthInfo_t().vRange) >= 8 ); + +C_ASSERT( sizeof(w64_AppOverrideKeys_t) >= 16 ); +C_ASSERT( offsetof(w64_AppOverrideKeys_t, pchKey) == 0 ); +C_ASSERT( sizeof(w64_AppOverrideKeys_t().pchKey) >= 8 ); +C_ASSERT( offsetof(w64_AppOverrideKeys_t, pchValue) == 8 ); +C_ASSERT( sizeof(w64_AppOverrideKeys_t().pchValue) >= 8 ); + +C_ASSERT( sizeof(u64_AppOverrideKeys_t) >= 16 ); +C_ASSERT( offsetof(u64_AppOverrideKeys_t, pchKey) == 0 ); +C_ASSERT( sizeof(u64_AppOverrideKeys_t().pchKey) >= 8 ); +C_ASSERT( offsetof(u64_AppOverrideKeys_t, pchValue) == 8 ); +C_ASSERT( sizeof(u64_AppOverrideKeys_t().pchValue) >= 8 ); + +C_ASSERT( sizeof(w32_AppOverrideKeys_t) >= 8 ); +C_ASSERT( offsetof(w32_AppOverrideKeys_t, pchKey) == 0 ); +C_ASSERT( sizeof(w32_AppOverrideKeys_t().pchKey) >= 4 ); +C_ASSERT( offsetof(w32_AppOverrideKeys_t, pchValue) == 4 ); +C_ASSERT( sizeof(w32_AppOverrideKeys_t().pchValue) >= 4 ); + +C_ASSERT( sizeof(u32_AppOverrideKeys_t) >= 8 ); +C_ASSERT( offsetof(u32_AppOverrideKeys_t, pchKey) == 0 ); +C_ASSERT( sizeof(u32_AppOverrideKeys_t().pchKey) >= 4 ); +C_ASSERT( offsetof(u32_AppOverrideKeys_t, pchValue) == 4 ); +C_ASSERT( sizeof(u32_AppOverrideKeys_t().pchValue) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_11030) >= 160 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRHeadsetView) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRHeadsetView) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVROverlay) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVROverlayView) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVROverlayView) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRResources) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRRenderModels) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRExtendedDisplay) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRSettings) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRApplications) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRTrackedCamera) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRScreenshots) == 104 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRDriverManager) == 112 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRInput) == 120 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRIOBuffer) == 128 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRSpatialAnchors) == 136 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRDebug) == 144 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRDebug) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_11030, m_pVRNotifications) == 152 ); +C_ASSERT( sizeof(w64_COpenVRContext_11030().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_11030) >= 160 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRHeadsetView) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRHeadsetView) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVROverlay) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVROverlayView) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVROverlayView) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRResources) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRRenderModels) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRExtendedDisplay) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRSettings) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRApplications) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRTrackedCamera) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRScreenshots) == 104 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRDriverManager) == 112 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRInput) == 120 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRIOBuffer) == 128 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRSpatialAnchors) == 136 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRDebug) == 144 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRDebug) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_11030, m_pVRNotifications) == 152 ); +C_ASSERT( sizeof(u64_COpenVRContext_11030().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_11030) >= 80 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRHeadsetView) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRHeadsetView) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVROverlay) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVROverlayView) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVROverlayView) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRResources) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRRenderModels) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRExtendedDisplay) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRSettings) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRApplications) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRTrackedCamera) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRScreenshots) == 52 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRDriverManager) == 56 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRInput) == 60 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRIOBuffer) == 64 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRSpatialAnchors) == 68 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRDebug) == 72 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRDebug) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_11030, m_pVRNotifications) == 76 ); +C_ASSERT( sizeof(w32_COpenVRContext_11030().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_11030) >= 80 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRHeadsetView) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRHeadsetView) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVROverlay) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVROverlayView) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVROverlayView) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRResources) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRRenderModels) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRExtendedDisplay) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRSettings) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRApplications) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRTrackedCamera) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRScreenshots) == 52 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRDriverManager) == 56 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRInput) == 60 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRIOBuffer) == 64 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRSpatialAnchors) == 68 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRDebug) == 72 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRDebug) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_11030, m_pVRNotifications) == 76 ); +C_ASSERT( sizeof(u32_COpenVRContext_11030().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_1517) >= 144 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRInput) == 104 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRDebug) == 128 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRDebug) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1517, m_pVRNotifications) == 136 ); +C_ASSERT( sizeof(w64_COpenVRContext_1517().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_1517) >= 144 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRInput) == 104 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRDebug) == 128 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRDebug) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1517, m_pVRNotifications) == 136 ); +C_ASSERT( sizeof(u64_COpenVRContext_1517().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_1517) >= 72 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRInput) == 52 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRDebug) == 64 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRDebug) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1517, m_pVRNotifications) == 68 ); +C_ASSERT( sizeof(w32_COpenVRContext_1517().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_1517) >= 72 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRInput) == 52 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRDebug) == 64 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRDebug) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1517, m_pVRNotifications) == 68 ); +C_ASSERT( sizeof(u32_COpenVRContext_1517().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_1210) >= 136 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRInput) == 104 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1210, m_pVRNotifications) == 128 ); +C_ASSERT( sizeof(w64_COpenVRContext_1210().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_1210) >= 136 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRInput) == 104 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRSpatialAnchors) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1210, m_pVRNotifications) == 128 ); +C_ASSERT( sizeof(u64_COpenVRContext_1210().m_pVRNotifications) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_1210) >= 68 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRInput) == 52 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1210, m_pVRNotifications) == 64 ); +C_ASSERT( sizeof(w32_COpenVRContext_1210().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_1210) >= 68 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRInput) == 52 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRSpatialAnchors) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1210, m_pVRNotifications) == 64 ); +C_ASSERT( sizeof(u32_COpenVRContext_1210().m_pVRNotifications) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_1016) >= 128 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRInput) == 104 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1016, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(w64_COpenVRContext_1016().m_pVRSpatialAnchors) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_1016) >= 128 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRInput) == 104 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRIOBuffer) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1016, m_pVRSpatialAnchors) == 120 ); +C_ASSERT( sizeof(u64_COpenVRContext_1016().m_pVRSpatialAnchors) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_1016) >= 64 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRInput) == 52 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1016, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(w32_COpenVRContext_1016().m_pVRSpatialAnchors) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_1016) >= 64 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRInput) == 52 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRIOBuffer) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1016, m_pVRSpatialAnchors) == 60 ); +C_ASSERT( sizeof(u32_COpenVRContext_1016().m_pVRSpatialAnchors) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_1015) >= 120 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRInput) == 104 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_1015, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(w64_COpenVRContext_1015().m_pVRIOBuffer) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_1015) >= 120 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRDriverManager) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRInput) == 104 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRInput) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_1015, m_pVRIOBuffer) == 112 ); +C_ASSERT( sizeof(u64_COpenVRContext_1015().m_pVRIOBuffer) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_1015) >= 60 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRInput) == 52 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_1015, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(w32_COpenVRContext_1015().m_pVRIOBuffer) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_1015) >= 60 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRDriverManager) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRInput) == 52 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRInput) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_1015, m_pVRIOBuffer) == 56 ); +C_ASSERT( sizeof(u32_COpenVRContext_1015().m_pVRIOBuffer) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_108) >= 104 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_108, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(w64_COpenVRContext_108().m_pVRDriverManager) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_108) >= 104 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_108, m_pVRDriverManager) == 96 ); +C_ASSERT( sizeof(u64_COpenVRContext_108().m_pVRDriverManager) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_108) >= 52 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_108, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(w32_COpenVRContext_108().m_pVRDriverManager) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_108) >= 52 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_108, m_pVRDriverManager) == 48 ); +C_ASSERT( sizeof(u32_COpenVRContext_108().m_pVRDriverManager) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_102) >= 96 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRResources) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_102, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(w64_COpenVRContext_102().m_pVRScreenshots) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_102) >= 96 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRResources) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRResources) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRRenderModels) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRExtendedDisplay) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRSettings) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRApplications) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRTrackedCamera) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_102, m_pVRScreenshots) == 88 ); +C_ASSERT( sizeof(u64_COpenVRContext_102().m_pVRScreenshots) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_102) >= 48 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRResources) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_102, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(w32_COpenVRContext_102().m_pVRScreenshots) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_102) >= 48 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRResources) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRResources) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRRenderModels) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRExtendedDisplay) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRSettings) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRApplications) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRTrackedCamera) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_102, m_pVRScreenshots) == 44 ); +C_ASSERT( sizeof(u32_COpenVRContext_102().m_pVRScreenshots) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_101) >= 88 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRTrackedCamera) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_101, m_pVRScreenshots) == 80 ); +C_ASSERT( sizeof(w64_COpenVRContext_101().m_pVRScreenshots) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_101) >= 88 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRTrackedCamera) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRTrackedCamera) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_101, m_pVRScreenshots) == 80 ); +C_ASSERT( sizeof(u64_COpenVRContext_101().m_pVRScreenshots) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_101) >= 44 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRTrackedCamera) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_101, m_pVRScreenshots) == 40 ); +C_ASSERT( sizeof(w32_COpenVRContext_101().m_pVRScreenshots) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_101) >= 44 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRTrackedCamera) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRTrackedCamera) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_101, m_pVRScreenshots) == 40 ); +C_ASSERT( sizeof(u32_COpenVRContext_101().m_pVRScreenshots) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_100) >= 80 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_100, m_pVRTrackedCamera) == 72 ); +C_ASSERT( sizeof(w64_COpenVRContext_100().m_pVRTrackedCamera) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_100) >= 80 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRApplications) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_100, m_pVRTrackedCamera) == 72 ); +C_ASSERT( sizeof(u64_COpenVRContext_100().m_pVRTrackedCamera) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_100) >= 40 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_100, m_pVRTrackedCamera) == 36 ); +C_ASSERT( sizeof(w32_COpenVRContext_100().m_pVRTrackedCamera) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_100) >= 40 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRApplications) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_100, m_pVRTrackedCamera) == 36 ); +C_ASSERT( sizeof(u32_COpenVRContext_100().m_pVRTrackedCamera) >= 4 ); + +C_ASSERT( sizeof(w64_COpenVRContext_0917) >= 72 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(w64_COpenVRContext_0917, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(w64_COpenVRContext_0917().m_pVRApplications) >= 8 ); + +C_ASSERT( sizeof(u64_COpenVRContext_0917) >= 72 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRSystem) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRChaperone) == 8 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRChaperone) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRChaperoneSetup) == 16 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRChaperoneSetup) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRCompositor) == 24 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRCompositor) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVROverlay) == 32 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVROverlay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRRenderModels) == 40 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRRenderModels) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRExtendedDisplay) == 48 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRExtendedDisplay) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRSettings) == 56 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRSettings) >= 8 ); +C_ASSERT( offsetof(u64_COpenVRContext_0917, m_pVRApplications) == 64 ); +C_ASSERT( sizeof(u64_COpenVRContext_0917().m_pVRApplications) >= 8 ); + +C_ASSERT( sizeof(w32_COpenVRContext_0917) >= 36 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(w32_COpenVRContext_0917, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(w32_COpenVRContext_0917().m_pVRApplications) >= 4 ); + +C_ASSERT( sizeof(u32_COpenVRContext_0917) >= 36 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRSystem) == 0 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRSystem) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRChaperone) == 4 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRChaperone) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRChaperoneSetup) == 8 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRChaperoneSetup) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRCompositor) == 12 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRCompositor) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVROverlay) == 16 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVROverlay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRRenderModels) == 20 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRRenderModels) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRExtendedDisplay) == 24 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRExtendedDisplay) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRSettings) == 28 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRSettings) >= 4 ); +C_ASSERT( offsetof(u32_COpenVRContext_0917, m_pVRApplications) == 32 ); +C_ASSERT( sizeof(u32_COpenVRContext_0917().m_pVRApplications) >= 4 ); + +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017) >= 112 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, eFrameType) == 0 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().eFrameType) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, nWidth) == 4 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().nWidth) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, nHeight) == 8 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().nHeight) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, nFrameSequence) == 16 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, trackedDevicePose) == 20 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().trackedDevicePose) >= 80 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_1017, ulFrameExposureTime) == 104 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_1017().ulFrameExposureTime) >= 8 ); + +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017) >= 112 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, eFrameType) == 0 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().eFrameType) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, nWidth) == 4 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().nWidth) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, nHeight) == 8 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().nHeight) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, nFrameSequence) == 16 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, trackedDevicePose) == 20 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().trackedDevicePose) >= 80 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_1017, ulFrameExposureTime) == 104 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_1017().ulFrameExposureTime) >= 8 ); + +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017) >= 112 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, eFrameType) == 0 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().eFrameType) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, nWidth) == 4 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().nWidth) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, nHeight) == 8 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().nHeight) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, nFrameSequence) == 16 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, trackedDevicePose) == 20 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().trackedDevicePose) >= 80 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_1017, ulFrameExposureTime) == 104 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_1017().ulFrameExposureTime) >= 8 ); + +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017) >= 108 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, eFrameType) == 0 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().eFrameType) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, nWidth) == 4 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().nWidth) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, nHeight) == 8 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().nHeight) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, nFrameSequence) == 16 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, trackedDevicePose) == 20 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().trackedDevicePose) >= 80 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_1017, ulFrameExposureTime) == 100 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_1017().ulFrameExposureTime) >= 8 ); + +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100) >= 100 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, eFrameType) == 0 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().eFrameType) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, nWidth) == 4 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().nWidth) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, nHeight) == 8 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().nHeight) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, nFrameSequence) == 16 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrameHeader_t_100, standingTrackedDevicePose) == 20 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrameHeader_t_100().standingTrackedDevicePose) >= 80 ); + +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100) >= 100 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, eFrameType) == 0 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().eFrameType) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, nWidth) == 4 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().nWidth) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, nHeight) == 8 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().nHeight) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, nFrameSequence) == 16 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrameHeader_t_100, standingTrackedDevicePose) == 20 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrameHeader_t_100().standingTrackedDevicePose) >= 80 ); + +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100) >= 100 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, eFrameType) == 0 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().eFrameType) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, nWidth) == 4 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().nWidth) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, nHeight) == 8 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().nHeight) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, nFrameSequence) == 16 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrameHeader_t_100, standingTrackedDevicePose) == 20 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrameHeader_t_100().standingTrackedDevicePose) >= 80 ); + +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100) >= 100 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, eFrameType) == 0 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().eFrameType) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, nWidth) == 4 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().nWidth) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, nHeight) == 8 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().nHeight) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().nBytesPerPixel) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, nFrameSequence) == 16 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrameHeader_t_100, standingTrackedDevicePose) == 20 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrameHeader_t_100().standingTrackedDevicePose) >= 80 ); + +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914) >= 152 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nWidth) == 4 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nHeight) == 8 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nImageDataSize) == 12 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nFrameSequence) == 16 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nISPFrameTimeStamp) == 20 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nISPFrameTimeStamp) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nISPReferenceTimeStamp) == 24 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nISPReferenceTimeStamp) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nSyncCounter) == 28 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nSyncCounter) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nExposureTime) == 32 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nExposureTime) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nBufferIndex) == 36 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nBufferCount) == 40 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_flFrameElapsedTime) == 48 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_flFrameCaptureTime) == 56 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_nFrameCaptureTicks) == 64 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_nFrameCaptureTicks) >= 8 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_bPoseIsValid) == 72 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_matDeviceToAbsoluteTracking) == 76 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_Pad) == 124 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_Pad) >= 16 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0914, m_pImageData) == 144 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0914().m_pImageData) >= 8 ); + +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914) >= 144 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nWidth) == 4 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nHeight) == 8 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nImageDataSize) == 12 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nFrameSequence) == 16 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nISPFrameTimeStamp) == 20 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nISPFrameTimeStamp) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nISPReferenceTimeStamp) == 24 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nISPReferenceTimeStamp) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nSyncCounter) == 28 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nSyncCounter) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nExposureTime) == 32 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nExposureTime) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nBufferIndex) == 36 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nBufferCount) == 40 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_flFrameElapsedTime) == 44 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_flFrameCaptureTime) == 52 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_nFrameCaptureTicks) == 60 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_nFrameCaptureTicks) >= 8 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_bPoseIsValid) == 68 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_matDeviceToAbsoluteTracking) == 72 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_Pad) == 120 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_Pad) >= 16 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0914, m_pImageData) == 136 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0914().m_pImageData) >= 8 ); + +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914) >= 144 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nWidth) == 4 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nHeight) == 8 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nImageDataSize) == 12 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nFrameSequence) == 16 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nISPFrameTimeStamp) == 20 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nISPFrameTimeStamp) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nISPReferenceTimeStamp) == 24 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nISPReferenceTimeStamp) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nSyncCounter) == 28 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nSyncCounter) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nExposureTime) == 32 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nExposureTime) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nBufferIndex) == 36 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nBufferCount) == 40 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_flFrameElapsedTime) == 48 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_flFrameCaptureTime) == 56 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_nFrameCaptureTicks) == 64 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_nFrameCaptureTicks) >= 8 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_bPoseIsValid) == 72 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_matDeviceToAbsoluteTracking) == 76 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_Pad) == 124 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_Pad) >= 16 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0914, m_pImageData) == 140 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0914().m_pImageData) >= 4 ); + +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914) >= 140 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nWidth) == 4 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nHeight) == 8 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nImageDataSize) == 12 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nFrameSequence) == 16 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nISPFrameTimeStamp) == 20 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nISPFrameTimeStamp) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nISPReferenceTimeStamp) == 24 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nISPReferenceTimeStamp) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nSyncCounter) == 28 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nSyncCounter) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nExposureTime) == 32 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nExposureTime) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nBufferIndex) == 36 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nBufferCount) == 40 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_flFrameElapsedTime) == 44 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_flFrameCaptureTime) == 52 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_nFrameCaptureTicks) == 60 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_nFrameCaptureTicks) >= 8 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_bPoseIsValid) == 68 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_matDeviceToAbsoluteTracking) == 72 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_Pad) == 120 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_Pad) >= 16 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0914, m_pImageData) == 136 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0914().m_pImageData) >= 4 ); + +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912) >= 128 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nWidth) == 4 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nHeight) == 8 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nFrameSequence) == 12 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nTimeStamp) == 16 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nTimeStamp) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nBufferIndex) == 20 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nBufferCount) == 24 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_nImageDataSize) == 28 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_flFrameElapsedTime) == 32 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_flFrameCaptureTime) == 40 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_bPoseIsValid) == 48 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_matDeviceToAbsoluteTracking) == 52 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_Pad) == 100 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_Pad) >= 16 ); +C_ASSERT( offsetof(w64_CameraVideoStreamFrame_t_0912, m_pImageData) == 120 ); +C_ASSERT( sizeof(w64_CameraVideoStreamFrame_t_0912().m_pImageData) >= 8 ); + +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912) >= 124 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nWidth) == 4 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nHeight) == 8 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nFrameSequence) == 12 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nTimeStamp) == 16 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nTimeStamp) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nBufferIndex) == 20 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nBufferCount) == 24 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_nImageDataSize) == 28 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_flFrameElapsedTime) == 32 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_flFrameCaptureTime) == 40 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_bPoseIsValid) == 48 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_matDeviceToAbsoluteTracking) == 52 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_Pad) == 100 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_Pad) >= 16 ); +C_ASSERT( offsetof(u64_CameraVideoStreamFrame_t_0912, m_pImageData) == 116 ); +C_ASSERT( sizeof(u64_CameraVideoStreamFrame_t_0912().m_pImageData) >= 8 ); + +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912) >= 120 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nWidth) == 4 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nHeight) == 8 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nFrameSequence) == 12 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nTimeStamp) == 16 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nTimeStamp) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nBufferIndex) == 20 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nBufferCount) == 24 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_nImageDataSize) == 28 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_flFrameElapsedTime) == 32 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_flFrameCaptureTime) == 40 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_bPoseIsValid) == 48 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_matDeviceToAbsoluteTracking) == 52 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_Pad) == 100 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_Pad) >= 16 ); +C_ASSERT( offsetof(w32_CameraVideoStreamFrame_t_0912, m_pImageData) == 116 ); +C_ASSERT( sizeof(w32_CameraVideoStreamFrame_t_0912().m_pImageData) >= 4 ); + +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912) >= 120 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nStreamFormat) == 0 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nStreamFormat) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nWidth) == 4 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nHeight) == 8 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nFrameSequence) == 12 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nFrameSequence) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nTimeStamp) == 16 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nTimeStamp) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nBufferIndex) == 20 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nBufferIndex) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nBufferCount) == 24 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nBufferCount) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_nImageDataSize) == 28 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_nImageDataSize) >= 4 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_flFrameElapsedTime) == 32 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_flFrameElapsedTime) >= 8 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_flFrameCaptureTime) == 40 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_flFrameCaptureTime) >= 8 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_bPoseIsValid) == 48 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_bPoseIsValid) >= 1 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_matDeviceToAbsoluteTracking) == 52 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_matDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_Pad) == 100 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_Pad) >= 16 ); +C_ASSERT( offsetof(u32_CameraVideoStreamFrame_t_0912, m_pImageData) == 116 ); +C_ASSERT( sizeof(u32_CameraVideoStreamFrame_t_0912().m_pImageData) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017) >= 184 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nSize) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nSize) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nNumVSyncsReadyForUse) == 176 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nNumVSyncsReadyForUse) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_1017, m_nNumVSyncsToFirstView) == 180 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_1017().m_nNumVSyncsToFirstView) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017) >= 184 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nSize) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nSize) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_HmdPose) == 96 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nNumVSyncsReadyForUse) == 176 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nNumVSyncsReadyForUse) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_1017, m_nNumVSyncsToFirstView) == 180 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_1017().m_nNumVSyncsToFirstView) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017) >= 184 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nSize) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nSize) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nNumVSyncsReadyForUse) == 176 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nNumVSyncsReadyForUse) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_1017, m_nNumVSyncsToFirstView) == 180 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_1017().m_nNumVSyncsToFirstView) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017) >= 184 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nSize) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nSize) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_HmdPose) == 96 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nNumVSyncsReadyForUse) == 176 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nNumVSyncsReadyForUse) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_1017, m_nNumVSyncsToFirstView) == 180 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_1017().m_nNumVSyncsToFirstView) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a) >= 176 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nSize) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nSize) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_103a, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_103a().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a) >= 176 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nSize) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nSize) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_103a, m_HmdPose) == 96 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_103a().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a) >= 176 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nSize) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nSize) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_103a, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_103a().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a) >= 176 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nSize) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nSize) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nNumMisPresented) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nNumMisPresented) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nNumDroppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_nReprojectionFlags) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_103a, m_HmdPose) == 96 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_103a().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102) >= 176 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_nSize) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_nSize) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_nReprojectionFlags) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_102, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_102().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102) >= 172 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_nSize) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_nSize) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_nReprojectionFlags) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flSystemTimeInSeconds) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flPreSubmitGpuMs) == 28 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flPostSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flTotalRenderGpuMs) == 36 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorRenderCpuMs) == 44 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorIdleCpuMs) == 48 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flClientFrameIntervalMs) == 52 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flPresentCallCpuMs) == 56 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flWaitForPresentCpuMs) == 60 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flSubmitFrameMs) == 64 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flWaitGetPosesCalledMs) == 68 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flNewPosesReadyMs) == 72 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flNewFrameReadyMs) == 76 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorUpdateStartMs) == 80 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorUpdateEndMs) == 84 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_flCompositorRenderStartMs) == 88 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_102, m_HmdPose) == 92 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_102().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102) >= 176 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_nSize) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_nSize) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_nReprojectionFlags) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flSystemTimeInSeconds) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flPreSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flPostSubmitGpuMs) == 36 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flTotalRenderGpuMs) == 40 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorRenderGpuMs) == 44 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorRenderCpuMs) == 48 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorIdleCpuMs) == 52 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flClientFrameIntervalMs) == 56 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flPresentCallCpuMs) == 60 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flWaitForPresentCpuMs) == 64 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flSubmitFrameMs) == 68 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flWaitGetPosesCalledMs) == 72 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flNewPosesReadyMs) == 76 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flNewFrameReadyMs) == 80 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorUpdateStartMs) == 84 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorUpdateEndMs) == 88 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_flCompositorRenderStartMs) == 92 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_102, m_HmdPose) == 96 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_102().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102) >= 172 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_nSize) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_nSize) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_nReprojectionFlags) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_nReprojectionFlags) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flSystemTimeInSeconds) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flPreSubmitGpuMs) == 28 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flPreSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flPostSubmitGpuMs) == 32 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flPostSubmitGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flTotalRenderGpuMs) == 36 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorRenderGpuMs) == 40 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorRenderCpuMs) == 44 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorIdleCpuMs) == 48 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flClientFrameIntervalMs) == 52 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flPresentCallCpuMs) == 56 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flWaitForPresentCpuMs) == 60 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flSubmitFrameMs) == 64 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flWaitGetPosesCalledMs) == 68 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flNewPosesReadyMs) == 72 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flNewFrameReadyMs) == 76 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorUpdateStartMs) == 80 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorUpdateEndMs) == 84 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_flCompositorRenderStartMs) == 88 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_102, m_HmdPose) == 92 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_102().m_HmdPose) >= 80 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920) >= 176 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nSize) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nSize) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_HmdPose) == 84 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nFidelityLevel) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0920, m_nReprojectionFlags) == 168 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0920().m_nReprojectionFlags) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920) >= 172 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nSize) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nSize) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_HmdPose) == 84 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nFidelityLevel) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0920, m_nReprojectionFlags) == 168 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0920().m_nReprojectionFlags) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920) >= 176 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nSize) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nSize) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_HmdPose) == 84 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nFidelityLevel) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0920, m_nReprojectionFlags) == 168 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0920().m_nReprojectionFlags) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920) >= 172 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nSize) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nSize) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_HmdPose) == 84 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nFidelityLevel) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0920, m_nReprojectionFlags) == 168 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0920().m_nReprojectionFlags) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915) >= 168 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_nSize) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_nSize) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_HmdPose) == 84 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0915, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0915().m_nFidelityLevel) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915) >= 168 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_nSize) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_nSize) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_HmdPose) == 84 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0915, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0915().m_nFidelityLevel) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915) >= 168 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_nSize) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_nSize) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_HmdPose) == 84 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0915, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0915().m_nFidelityLevel) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915) >= 168 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_nSize) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_nSize) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_nFrameIndex) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_nFrameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_nNumFramePresents) == 8 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_nNumFramePresents) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_nNumDroppedFrames) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_nNumDroppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flSystemTimeInSeconds) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flSystemTimeInSeconds) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flSceneRenderGpuMs) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flTotalRenderGpuMs) == 28 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flTotalRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorRenderGpuMs) == 32 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorRenderCpuMs) == 36 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorIdleCpuMs) == 40 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorIdleCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flClientFrameIntervalMs) == 44 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flClientFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flPresentCallCpuMs) == 48 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flWaitForPresentCpuMs) == 52 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flWaitForPresentCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flSubmitFrameMs) == 56 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flSubmitFrameMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flWaitGetPosesCalledMs) == 60 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flWaitGetPosesCalledMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flNewPosesReadyMs) == 64 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flNewPosesReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flNewFrameReadyMs) == 68 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flNewFrameReadyMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorUpdateStartMs) == 72 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorUpdateStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorUpdateEndMs) == 76 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorUpdateEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_flCompositorRenderStartMs) == 80 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_flCompositorRenderStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_HmdPose) == 84 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_HmdPose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0915, m_nFidelityLevel) == 164 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0915().m_nFidelityLevel) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914) >= 160 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, size) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().size) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, frameStart) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().frameStart) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, frameVSync) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().frameVSync) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, droppedFrames) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, frameIndex) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().frameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, pose) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().pose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, prediction) == 108 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().prediction) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_flCompositorUpdateCpuMs) == 148 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_flCompositorUpdateCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0914, m_nPresents) == 152 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0914().m_nPresents) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914) >= 152 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, size) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().size) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, frameStart) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().frameStart) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, frameVSync) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().frameVSync) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, droppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, frameIndex) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().frameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, pose) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().pose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, prediction) == 104 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().prediction) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_flCompositorUpdateCpuMs) == 144 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_flCompositorUpdateCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0914, m_nPresents) == 148 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0914().m_nPresents) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914) >= 160 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, size) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().size) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, frameStart) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().frameStart) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, frameVSync) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().frameVSync) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, droppedFrames) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, frameIndex) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().frameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, pose) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().pose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, prediction) == 108 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().prediction) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_flCompositorUpdateCpuMs) == 148 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_flCompositorUpdateCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0914, m_nPresents) == 152 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0914().m_nPresents) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914) >= 152 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, size) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().size) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, frameStart) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().frameStart) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, frameVSync) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().frameVSync) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, droppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, frameIndex) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().frameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, pose) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().pose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, prediction) == 104 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().prediction) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_flCompositorUpdateCpuMs) == 144 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_flCompositorUpdateCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0914, m_nPresents) == 148 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0914().m_nPresents) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913) >= 152 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, size) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().size) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, frameStart) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().frameStart) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, frameVSync) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().frameVSync) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, droppedFrames) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, frameIndex) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().frameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, pose) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().pose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, prediction) == 108 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().prediction) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0913, m_flCompositorUpdateCpuMs) == 148 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0913().m_flCompositorUpdateCpuMs) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913) >= 148 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, size) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().size) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, frameStart) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().frameStart) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, frameVSync) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().frameVSync) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, droppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, frameIndex) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().frameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, pose) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().pose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, prediction) == 104 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().prediction) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0913, m_flCompositorUpdateCpuMs) == 144 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0913().m_flCompositorUpdateCpuMs) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913) >= 152 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, size) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().size) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, frameStart) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().frameStart) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, frameVSync) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().frameVSync) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, droppedFrames) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, frameIndex) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().frameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, pose) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().pose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, prediction) == 108 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().prediction) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0913, m_flCompositorUpdateCpuMs) == 148 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0913().m_flCompositorUpdateCpuMs) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913) >= 148 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, size) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().size) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, frameStart) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().frameStart) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, frameVSync) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().frameVSync) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, droppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, frameIndex) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().frameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, pose) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().pose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, prediction) == 104 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().prediction) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flHandoffEndMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0913, m_flCompositorUpdateCpuMs) == 144 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0913().m_flCompositorUpdateCpuMs) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912) >= 152 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, size) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().size) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, frameStart) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().frameStart) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, frameVSync) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().frameVSync) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, droppedFrames) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, frameIndex) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().frameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, pose) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().pose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, prediction) == 108 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().prediction) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_0912, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_0912().m_flHandoffEndMs) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912) >= 144 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, size) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().size) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, frameStart) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().frameStart) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, frameVSync) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().frameVSync) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, droppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, frameIndex) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().frameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, pose) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().pose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, prediction) == 104 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().prediction) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_0912, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_0912().m_flHandoffEndMs) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912) >= 152 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, size) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().size) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, frameStart) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().frameStart) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, frameVSync) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().frameVSync) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, droppedFrames) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, frameIndex) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().frameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, pose) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().pose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, prediction) == 108 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().prediction) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flHandoffStartMs) == 140 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_0912, m_flHandoffEndMs) == 144 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_0912().m_flHandoffEndMs) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912) >= 144 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, size) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().size) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, frameStart) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().frameStart) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, frameVSync) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().frameVSync) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, droppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, frameIndex) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().frameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, pose) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().pose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, prediction) == 104 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().prediction) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flRunningStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flHandoffStartMs) == 136 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flHandoffStartMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_0912, m_flHandoffEndMs) == 140 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_0912().m_flHandoffEndMs) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093) >= 144 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, size) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().size) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, frameStart) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().frameStart) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, frameVSync) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().frameVSync) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, droppedFrames) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, frameIndex) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().frameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, pose) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().pose) >= 80 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, prediction) == 108 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().prediction) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_093, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_093().m_flRunningStartMs) >= 4 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093) >= 136 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, size) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().size) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, frameStart) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().frameStart) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, frameVSync) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().frameVSync) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, droppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, frameIndex) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().frameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, pose) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().pose) >= 80 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, prediction) == 104 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().prediction) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_093, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_093().m_flRunningStartMs) >= 4 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093) >= 144 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, size) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().size) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, frameStart) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().frameStart) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, frameVSync) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().frameVSync) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, droppedFrames) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, frameIndex) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().frameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, pose) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().pose) >= 80 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, prediction) == 108 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().prediction) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flFrameIntervalMs) == 112 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flSceneRenderCpuMs) == 116 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flSceneRenderGpuMs) == 120 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flCompositorRenderCpuMs) == 124 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flCompositorRenderGpuMs) == 128 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flPresentCallCpuMs) == 132 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_093, m_flRunningStartMs) == 136 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_093().m_flRunningStartMs) >= 4 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093) >= 136 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, size) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().size) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, frameStart) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().frameStart) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, frameVSync) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().frameVSync) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, droppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, frameIndex) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().frameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, pose) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().pose) >= 80 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, prediction) == 104 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().prediction) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flFrameIntervalMs) == 108 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flFrameIntervalMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flSceneRenderCpuMs) == 112 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flSceneRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flSceneRenderGpuMs) == 116 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flSceneRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flCompositorRenderCpuMs) == 120 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flCompositorRenderCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flCompositorRenderGpuMs) == 124 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flCompositorRenderGpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flPresentCallCpuMs) == 128 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flPresentCallCpuMs) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_093, m_flRunningStartMs) == 132 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_093().m_flRunningStartMs) >= 4 ); + +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090) >= 112 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, size) == 0 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().size) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, frameStart) == 8 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().frameStart) >= 8 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, frameVSync) == 16 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().frameVSync) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, droppedFrames) == 20 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, frameIndex) == 24 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().frameIndex) >= 4 ); +C_ASSERT( offsetof(w64_Compositor_FrameTiming_090, pose) == 28 ); +C_ASSERT( sizeof(w64_Compositor_FrameTiming_090().pose) >= 80 ); + +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090) >= 104 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, size) == 0 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().size) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, frameStart) == 4 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().frameStart) >= 8 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, frameVSync) == 12 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().frameVSync) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, droppedFrames) == 16 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, frameIndex) == 20 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().frameIndex) >= 4 ); +C_ASSERT( offsetof(u64_Compositor_FrameTiming_090, pose) == 24 ); +C_ASSERT( sizeof(u64_Compositor_FrameTiming_090().pose) >= 80 ); + +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090) >= 112 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, size) == 0 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().size) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, frameStart) == 8 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().frameStart) >= 8 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, frameVSync) == 16 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().frameVSync) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, droppedFrames) == 20 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().droppedFrames) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, frameIndex) == 24 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().frameIndex) >= 4 ); +C_ASSERT( offsetof(w32_Compositor_FrameTiming_090, pose) == 28 ); +C_ASSERT( sizeof(w32_Compositor_FrameTiming_090().pose) >= 80 ); + +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090) >= 104 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, size) == 0 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().size) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, frameStart) == 4 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().frameStart) >= 8 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, frameVSync) == 12 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().frameVSync) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, droppedFrames) == 16 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().droppedFrames) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, frameIndex) == 20 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().frameIndex) >= 4 ); +C_ASSERT( offsetof(u32_Compositor_FrameTiming_090, pose) == 24 ); +C_ASSERT( sizeof(u32_Compositor_FrameTiming_090().pose) >= 80 ); + +C_ASSERT( sizeof(w64_D3D12TextureData_t) >= 24 ); +C_ASSERT( offsetof(w64_D3D12TextureData_t, m_pResource) == 0 ); +C_ASSERT( sizeof(w64_D3D12TextureData_t().m_pResource) >= 8 ); +C_ASSERT( offsetof(w64_D3D12TextureData_t, m_pCommandQueue) == 8 ); +C_ASSERT( sizeof(w64_D3D12TextureData_t().m_pCommandQueue) >= 8 ); +C_ASSERT( offsetof(w64_D3D12TextureData_t, m_nNodeMask) == 16 ); +C_ASSERT( sizeof(w64_D3D12TextureData_t().m_nNodeMask) >= 4 ); + +C_ASSERT( sizeof(u64_D3D12TextureData_t) >= 24 ); +C_ASSERT( offsetof(u64_D3D12TextureData_t, m_pResource) == 0 ); +C_ASSERT( sizeof(u64_D3D12TextureData_t().m_pResource) >= 8 ); +C_ASSERT( offsetof(u64_D3D12TextureData_t, m_pCommandQueue) == 8 ); +C_ASSERT( sizeof(u64_D3D12TextureData_t().m_pCommandQueue) >= 8 ); +C_ASSERT( offsetof(u64_D3D12TextureData_t, m_nNodeMask) == 16 ); +C_ASSERT( sizeof(u64_D3D12TextureData_t().m_nNodeMask) >= 4 ); + +C_ASSERT( sizeof(w32_D3D12TextureData_t) >= 12 ); +C_ASSERT( offsetof(w32_D3D12TextureData_t, m_pResource) == 0 ); +C_ASSERT( sizeof(w32_D3D12TextureData_t().m_pResource) >= 4 ); +C_ASSERT( offsetof(w32_D3D12TextureData_t, m_pCommandQueue) == 4 ); +C_ASSERT( sizeof(w32_D3D12TextureData_t().m_pCommandQueue) >= 4 ); +C_ASSERT( offsetof(w32_D3D12TextureData_t, m_nNodeMask) == 8 ); +C_ASSERT( sizeof(w32_D3D12TextureData_t().m_nNodeMask) >= 4 ); + +C_ASSERT( sizeof(u32_D3D12TextureData_t) >= 12 ); +C_ASSERT( offsetof(u32_D3D12TextureData_t, m_pResource) == 0 ); +C_ASSERT( sizeof(u32_D3D12TextureData_t().m_pResource) >= 4 ); +C_ASSERT( offsetof(u32_D3D12TextureData_t, m_pCommandQueue) == 4 ); +C_ASSERT( sizeof(u32_D3D12TextureData_t().m_pCommandQueue) >= 4 ); +C_ASSERT( offsetof(u32_D3D12TextureData_t, m_nNodeMask) == 8 ); +C_ASSERT( sizeof(u32_D3D12TextureData_t().m_nNodeMask) >= 4 ); + +C_ASSERT( sizeof(w64_HiddenAreaMesh_t) >= 16 ); +C_ASSERT( offsetof(w64_HiddenAreaMesh_t, pVertexData) == 0 ); +C_ASSERT( sizeof(w64_HiddenAreaMesh_t().pVertexData) >= 8 ); +C_ASSERT( offsetof(w64_HiddenAreaMesh_t, unTriangleCount) == 8 ); +C_ASSERT( sizeof(w64_HiddenAreaMesh_t().unTriangleCount) >= 4 ); + +C_ASSERT( sizeof(u64_HiddenAreaMesh_t) >= 16 ); +C_ASSERT( offsetof(u64_HiddenAreaMesh_t, pVertexData) == 0 ); +C_ASSERT( sizeof(u64_HiddenAreaMesh_t().pVertexData) >= 8 ); +C_ASSERT( offsetof(u64_HiddenAreaMesh_t, unTriangleCount) == 8 ); +C_ASSERT( sizeof(u64_HiddenAreaMesh_t().unTriangleCount) >= 4 ); + +C_ASSERT( sizeof(w32_HiddenAreaMesh_t) >= 8 ); +C_ASSERT( offsetof(w32_HiddenAreaMesh_t, pVertexData) == 0 ); +C_ASSERT( sizeof(w32_HiddenAreaMesh_t().pVertexData) >= 4 ); +C_ASSERT( offsetof(w32_HiddenAreaMesh_t, unTriangleCount) == 4 ); +C_ASSERT( sizeof(w32_HiddenAreaMesh_t().unTriangleCount) >= 4 ); + +C_ASSERT( sizeof(u32_HiddenAreaMesh_t) >= 8 ); +C_ASSERT( offsetof(u32_HiddenAreaMesh_t, pVertexData) == 0 ); +C_ASSERT( sizeof(u32_HiddenAreaMesh_t().pVertexData) >= 4 ); +C_ASSERT( offsetof(u32_HiddenAreaMesh_t, unTriangleCount) == 4 ); +C_ASSERT( sizeof(u32_HiddenAreaMesh_t().unTriangleCount) >= 4 ); + +C_ASSERT( sizeof(w64_InputAnalogActionData_t) >= 48 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, x) == 16 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, y) == 20 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, z) == 24 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().z) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, deltaX) == 28 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().deltaX) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, deltaY) == 32 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().deltaY) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, deltaZ) == 36 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().deltaZ) >= 4 ); +C_ASSERT( offsetof(w64_InputAnalogActionData_t, fUpdateTime) == 40 ); +C_ASSERT( sizeof(w64_InputAnalogActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(u64_InputAnalogActionData_t) >= 48 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, x) == 16 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, y) == 20 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, z) == 24 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().z) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, deltaX) == 28 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().deltaX) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, deltaY) == 32 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().deltaY) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, deltaZ) == 36 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().deltaZ) >= 4 ); +C_ASSERT( offsetof(u64_InputAnalogActionData_t, fUpdateTime) == 40 ); +C_ASSERT( sizeof(u64_InputAnalogActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(w32_InputAnalogActionData_t) >= 48 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, x) == 16 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, y) == 20 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, z) == 24 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().z) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, deltaX) == 28 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().deltaX) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, deltaY) == 32 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().deltaY) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, deltaZ) == 36 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().deltaZ) >= 4 ); +C_ASSERT( offsetof(w32_InputAnalogActionData_t, fUpdateTime) == 40 ); +C_ASSERT( sizeof(w32_InputAnalogActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(u32_InputAnalogActionData_t) >= 40 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, x) == 12 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, y) == 16 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, z) == 20 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().z) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, deltaX) == 24 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().deltaX) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, deltaY) == 28 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().deltaY) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, deltaZ) == 32 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().deltaZ) >= 4 ); +C_ASSERT( offsetof(u32_InputAnalogActionData_t, fUpdateTime) == 36 ); +C_ASSERT( sizeof(u32_InputAnalogActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(w64_InputDigitalActionData_t) >= 24 ); +C_ASSERT( offsetof(w64_InputDigitalActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputDigitalActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputDigitalActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputDigitalActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w64_InputDigitalActionData_t, bState) == 16 ); +C_ASSERT( sizeof(w64_InputDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(w64_InputDigitalActionData_t, bChanged) == 17 ); +C_ASSERT( sizeof(w64_InputDigitalActionData_t().bChanged) >= 1 ); +C_ASSERT( offsetof(w64_InputDigitalActionData_t, fUpdateTime) == 20 ); +C_ASSERT( sizeof(w64_InputDigitalActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(u64_InputDigitalActionData_t) >= 24 ); +C_ASSERT( offsetof(u64_InputDigitalActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputDigitalActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputDigitalActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputDigitalActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u64_InputDigitalActionData_t, bState) == 16 ); +C_ASSERT( sizeof(u64_InputDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(u64_InputDigitalActionData_t, bChanged) == 17 ); +C_ASSERT( sizeof(u64_InputDigitalActionData_t().bChanged) >= 1 ); +C_ASSERT( offsetof(u64_InputDigitalActionData_t, fUpdateTime) == 20 ); +C_ASSERT( sizeof(u64_InputDigitalActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(w32_InputDigitalActionData_t) >= 24 ); +C_ASSERT( offsetof(w32_InputDigitalActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputDigitalActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputDigitalActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputDigitalActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w32_InputDigitalActionData_t, bState) == 16 ); +C_ASSERT( sizeof(w32_InputDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(w32_InputDigitalActionData_t, bChanged) == 17 ); +C_ASSERT( sizeof(w32_InputDigitalActionData_t().bChanged) >= 1 ); +C_ASSERT( offsetof(w32_InputDigitalActionData_t, fUpdateTime) == 20 ); +C_ASSERT( sizeof(w32_InputDigitalActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(u32_InputDigitalActionData_t) >= 20 ); +C_ASSERT( offsetof(u32_InputDigitalActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputDigitalActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputDigitalActionData_t, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputDigitalActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u32_InputDigitalActionData_t, bState) == 12 ); +C_ASSERT( sizeof(u32_InputDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(u32_InputDigitalActionData_t, bChanged) == 13 ); +C_ASSERT( sizeof(u32_InputDigitalActionData_t().bChanged) >= 1 ); +C_ASSERT( offsetof(u32_InputDigitalActionData_t, fUpdateTime) == 16 ); +C_ASSERT( sizeof(u32_InputDigitalActionData_t().fUpdateTime) >= 4 ); + +C_ASSERT( sizeof(w64_InputOriginInfo_t) >= 144 ); +C_ASSERT( offsetof(w64_InputOriginInfo_t, devicePath) == 0 ); +C_ASSERT( sizeof(w64_InputOriginInfo_t().devicePath) >= 8 ); +C_ASSERT( offsetof(w64_InputOriginInfo_t, trackedDeviceIndex) == 8 ); +C_ASSERT( sizeof(w64_InputOriginInfo_t().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_InputOriginInfo_t, rchRenderModelComponentName) == 12 ); +C_ASSERT( sizeof(w64_InputOriginInfo_t().rchRenderModelComponentName) >= 128 ); + +C_ASSERT( sizeof(u64_InputOriginInfo_t) >= 144 ); +C_ASSERT( offsetof(u64_InputOriginInfo_t, devicePath) == 0 ); +C_ASSERT( sizeof(u64_InputOriginInfo_t().devicePath) >= 8 ); +C_ASSERT( offsetof(u64_InputOriginInfo_t, trackedDeviceIndex) == 8 ); +C_ASSERT( sizeof(u64_InputOriginInfo_t().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_InputOriginInfo_t, rchRenderModelComponentName) == 12 ); +C_ASSERT( sizeof(u64_InputOriginInfo_t().rchRenderModelComponentName) >= 128 ); + +C_ASSERT( sizeof(w32_InputOriginInfo_t) >= 144 ); +C_ASSERT( offsetof(w32_InputOriginInfo_t, devicePath) == 0 ); +C_ASSERT( sizeof(w32_InputOriginInfo_t().devicePath) >= 8 ); +C_ASSERT( offsetof(w32_InputOriginInfo_t, trackedDeviceIndex) == 8 ); +C_ASSERT( sizeof(w32_InputOriginInfo_t().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_InputOriginInfo_t, rchRenderModelComponentName) == 12 ); +C_ASSERT( sizeof(w32_InputOriginInfo_t().rchRenderModelComponentName) >= 128 ); + +C_ASSERT( sizeof(u32_InputOriginInfo_t) >= 140 ); +C_ASSERT( offsetof(u32_InputOriginInfo_t, devicePath) == 0 ); +C_ASSERT( sizeof(u32_InputOriginInfo_t().devicePath) >= 8 ); +C_ASSERT( offsetof(u32_InputOriginInfo_t, trackedDeviceIndex) == 8 ); +C_ASSERT( sizeof(u32_InputOriginInfo_t().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_InputOriginInfo_t, rchRenderModelComponentName) == 12 ); +C_ASSERT( sizeof(u32_InputOriginInfo_t().rchRenderModelComponentName) >= 128 ); + +C_ASSERT( sizeof(w64_InputPoseActionData_t) >= 96 ); +C_ASSERT( offsetof(w64_InputPoseActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputPoseActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputPoseActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputPoseActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w64_InputPoseActionData_t, pose) == 16 ); +C_ASSERT( sizeof(w64_InputPoseActionData_t().pose) >= 80 ); + +C_ASSERT( sizeof(u64_InputPoseActionData_t) >= 96 ); +C_ASSERT( offsetof(u64_InputPoseActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputPoseActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputPoseActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputPoseActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u64_InputPoseActionData_t, pose) == 16 ); +C_ASSERT( sizeof(u64_InputPoseActionData_t().pose) >= 80 ); + +C_ASSERT( sizeof(w32_InputPoseActionData_t) >= 96 ); +C_ASSERT( offsetof(w32_InputPoseActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputPoseActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputPoseActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputPoseActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w32_InputPoseActionData_t, pose) == 16 ); +C_ASSERT( sizeof(w32_InputPoseActionData_t().pose) >= 80 ); + +C_ASSERT( sizeof(u32_InputPoseActionData_t) >= 92 ); +C_ASSERT( offsetof(u32_InputPoseActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputPoseActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputPoseActionData_t, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputPoseActionData_t().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u32_InputPoseActionData_t, pose) == 12 ); +C_ASSERT( sizeof(u32_InputPoseActionData_t().pose) >= 80 ); + +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_113b) >= 16 ); +C_ASSERT( offsetof(w64_InputSkeletalActionData_t_113b, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_113b().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputSkeletalActionData_t_113b, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_113b().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_113b) >= 16 ); +C_ASSERT( offsetof(u64_InputSkeletalActionData_t_113b, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_113b().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputSkeletalActionData_t_113b, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_113b().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_113b) >= 16 ); +C_ASSERT( offsetof(w32_InputSkeletalActionData_t_113b, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_113b().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputSkeletalActionData_t_113b, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_113b().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_113b) >= 12 ); +C_ASSERT( offsetof(u32_InputSkeletalActionData_t_113b, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_113b().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputSkeletalActionData_t_113b, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_113b().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_1016) >= 24 ); +C_ASSERT( offsetof(w64_InputSkeletalActionData_t_1016, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_1016().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputSkeletalActionData_t_1016, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_1016().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w64_InputSkeletalActionData_t_1016, boneCount) == 16 ); +C_ASSERT( sizeof(w64_InputSkeletalActionData_t_1016().boneCount) >= 4 ); + +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_1016) >= 24 ); +C_ASSERT( offsetof(u64_InputSkeletalActionData_t_1016, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_1016().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputSkeletalActionData_t_1016, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_1016().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u64_InputSkeletalActionData_t_1016, boneCount) == 16 ); +C_ASSERT( sizeof(u64_InputSkeletalActionData_t_1016().boneCount) >= 4 ); + +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_1016) >= 24 ); +C_ASSERT( offsetof(w32_InputSkeletalActionData_t_1016, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_1016().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputSkeletalActionData_t_1016, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_1016().activeOrigin) >= 8 ); +C_ASSERT( offsetof(w32_InputSkeletalActionData_t_1016, boneCount) == 16 ); +C_ASSERT( sizeof(w32_InputSkeletalActionData_t_1016().boneCount) >= 4 ); + +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_1016) >= 16 ); +C_ASSERT( offsetof(u32_InputSkeletalActionData_t_1016, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_1016().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputSkeletalActionData_t_1016, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_1016().activeOrigin) >= 8 ); +C_ASSERT( offsetof(u32_InputSkeletalActionData_t_1016, boneCount) == 12 ); +C_ASSERT( sizeof(u32_InputSkeletalActionData_t_1016().boneCount) >= 4 ); + +C_ASSERT( sizeof(w64_InputSkeletonActionData_t) >= 16 ); +C_ASSERT( offsetof(w64_InputSkeletonActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w64_InputSkeletonActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w64_InputSkeletonActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w64_InputSkeletonActionData_t().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(u64_InputSkeletonActionData_t) >= 16 ); +C_ASSERT( offsetof(u64_InputSkeletonActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u64_InputSkeletonActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u64_InputSkeletonActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(u64_InputSkeletonActionData_t().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(w32_InputSkeletonActionData_t) >= 16 ); +C_ASSERT( offsetof(w32_InputSkeletonActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(w32_InputSkeletonActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(w32_InputSkeletonActionData_t, activeOrigin) == 8 ); +C_ASSERT( sizeof(w32_InputSkeletonActionData_t().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(u32_InputSkeletonActionData_t) >= 12 ); +C_ASSERT( offsetof(u32_InputSkeletonActionData_t, bActive) == 0 ); +C_ASSERT( sizeof(u32_InputSkeletonActionData_t().bActive) >= 1 ); +C_ASSERT( offsetof(u32_InputSkeletonActionData_t, activeOrigin) == 4 ); +C_ASSERT( sizeof(u32_InputSkeletonActionData_t().activeOrigin) >= 8 ); + +C_ASSERT( sizeof(w64_NotificationBitmap) >= 24 ); +C_ASSERT( offsetof(w64_NotificationBitmap, bytes) == 0 ); +C_ASSERT( sizeof(w64_NotificationBitmap().bytes) >= 8 ); +C_ASSERT( offsetof(w64_NotificationBitmap, width) == 8 ); +C_ASSERT( sizeof(w64_NotificationBitmap().width) >= 4 ); +C_ASSERT( offsetof(w64_NotificationBitmap, height) == 12 ); +C_ASSERT( sizeof(w64_NotificationBitmap().height) >= 4 ); +C_ASSERT( offsetof(w64_NotificationBitmap, depth) == 16 ); +C_ASSERT( sizeof(w64_NotificationBitmap().depth) >= 4 ); + +C_ASSERT( sizeof(u64_NotificationBitmap) >= 20 ); +C_ASSERT( offsetof(u64_NotificationBitmap, bytes) == 0 ); +C_ASSERT( sizeof(u64_NotificationBitmap().bytes) >= 8 ); +C_ASSERT( offsetof(u64_NotificationBitmap, width) == 8 ); +C_ASSERT( sizeof(u64_NotificationBitmap().width) >= 4 ); +C_ASSERT( offsetof(u64_NotificationBitmap, height) == 12 ); +C_ASSERT( sizeof(u64_NotificationBitmap().height) >= 4 ); +C_ASSERT( offsetof(u64_NotificationBitmap, depth) == 16 ); +C_ASSERT( sizeof(u64_NotificationBitmap().depth) >= 4 ); + +C_ASSERT( sizeof(w32_NotificationBitmap) >= 16 ); +C_ASSERT( offsetof(w32_NotificationBitmap, bytes) == 0 ); +C_ASSERT( sizeof(w32_NotificationBitmap().bytes) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap, width) == 4 ); +C_ASSERT( sizeof(w32_NotificationBitmap().width) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap, height) == 8 ); +C_ASSERT( sizeof(w32_NotificationBitmap().height) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap, depth) == 12 ); +C_ASSERT( sizeof(w32_NotificationBitmap().depth) >= 4 ); + +C_ASSERT( sizeof(u32_NotificationBitmap) >= 16 ); +C_ASSERT( offsetof(u32_NotificationBitmap, bytes) == 0 ); +C_ASSERT( sizeof(u32_NotificationBitmap().bytes) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap, width) == 4 ); +C_ASSERT( sizeof(u32_NotificationBitmap().width) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap, height) == 8 ); +C_ASSERT( sizeof(u32_NotificationBitmap().height) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap, depth) == 12 ); +C_ASSERT( sizeof(u32_NotificationBitmap().depth) >= 4 ); + +C_ASSERT( sizeof(w64_NotificationBitmap_t) >= 24 ); +C_ASSERT( offsetof(w64_NotificationBitmap_t, m_pImageData) == 0 ); +C_ASSERT( sizeof(w64_NotificationBitmap_t().m_pImageData) >= 8 ); +C_ASSERT( offsetof(w64_NotificationBitmap_t, m_nWidth) == 8 ); +C_ASSERT( sizeof(w64_NotificationBitmap_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_NotificationBitmap_t, m_nHeight) == 12 ); +C_ASSERT( sizeof(w64_NotificationBitmap_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_NotificationBitmap_t, m_nBytesPerPixel) == 16 ); +C_ASSERT( sizeof(w64_NotificationBitmap_t().m_nBytesPerPixel) >= 4 ); + +C_ASSERT( sizeof(u64_NotificationBitmap_t) >= 24 ); +C_ASSERT( offsetof(u64_NotificationBitmap_t, m_pImageData) == 0 ); +C_ASSERT( sizeof(u64_NotificationBitmap_t().m_pImageData) >= 8 ); +C_ASSERT( offsetof(u64_NotificationBitmap_t, m_nWidth) == 8 ); +C_ASSERT( sizeof(u64_NotificationBitmap_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_NotificationBitmap_t, m_nHeight) == 12 ); +C_ASSERT( sizeof(u64_NotificationBitmap_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_NotificationBitmap_t, m_nBytesPerPixel) == 16 ); +C_ASSERT( sizeof(u64_NotificationBitmap_t().m_nBytesPerPixel) >= 4 ); + +C_ASSERT( sizeof(w32_NotificationBitmap_t) >= 16 ); +C_ASSERT( offsetof(w32_NotificationBitmap_t, m_pImageData) == 0 ); +C_ASSERT( sizeof(w32_NotificationBitmap_t().m_pImageData) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap_t, m_nWidth) == 4 ); +C_ASSERT( sizeof(w32_NotificationBitmap_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap_t, m_nHeight) == 8 ); +C_ASSERT( sizeof(w32_NotificationBitmap_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_NotificationBitmap_t, m_nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(w32_NotificationBitmap_t().m_nBytesPerPixel) >= 4 ); + +C_ASSERT( sizeof(u32_NotificationBitmap_t) >= 16 ); +C_ASSERT( offsetof(u32_NotificationBitmap_t, m_pImageData) == 0 ); +C_ASSERT( sizeof(u32_NotificationBitmap_t().m_pImageData) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap_t, m_nWidth) == 4 ); +C_ASSERT( sizeof(u32_NotificationBitmap_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap_t, m_nHeight) == 8 ); +C_ASSERT( sizeof(u32_NotificationBitmap_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_NotificationBitmap_t, m_nBytesPerPixel) == 12 ); +C_ASSERT( sizeof(u32_NotificationBitmap_t().m_nBytesPerPixel) >= 4 ); + +C_ASSERT( sizeof(w64_RenderModel_t_0912) >= 32 ); +C_ASSERT( offsetof(w64_RenderModel_t_0912, rVertexData) == 0 ); +C_ASSERT( sizeof(w64_RenderModel_t_0912().rVertexData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_t_0912, unVertexCount) == 8 ); +C_ASSERT( sizeof(w64_RenderModel_t_0912().unVertexCount) >= 4 ); +C_ASSERT( offsetof(w64_RenderModel_t_0912, rIndexData) == 16 ); +C_ASSERT( sizeof(w64_RenderModel_t_0912().rIndexData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_t_0912, unTriangleCount) == 24 ); +C_ASSERT( sizeof(w64_RenderModel_t_0912().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(w64_RenderModel_t_0912, diffuseTextureId) == 28 ); +C_ASSERT( sizeof(w64_RenderModel_t_0912().diffuseTextureId) >= 4 ); + +C_ASSERT( sizeof(u64_RenderModel_t_0912) >= 28 ); +C_ASSERT( offsetof(u64_RenderModel_t_0912, rVertexData) == 0 ); +C_ASSERT( sizeof(u64_RenderModel_t_0912().rVertexData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_t_0912, unVertexCount) == 8 ); +C_ASSERT( sizeof(u64_RenderModel_t_0912().unVertexCount) >= 4 ); +C_ASSERT( offsetof(u64_RenderModel_t_0912, rIndexData) == 12 ); +C_ASSERT( sizeof(u64_RenderModel_t_0912().rIndexData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_t_0912, unTriangleCount) == 20 ); +C_ASSERT( sizeof(u64_RenderModel_t_0912().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(u64_RenderModel_t_0912, diffuseTextureId) == 24 ); +C_ASSERT( sizeof(u64_RenderModel_t_0912().diffuseTextureId) >= 4 ); + +C_ASSERT( sizeof(w32_RenderModel_t_0912) >= 20 ); +C_ASSERT( offsetof(w32_RenderModel_t_0912, rVertexData) == 0 ); +C_ASSERT( sizeof(w32_RenderModel_t_0912().rVertexData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_0912, unVertexCount) == 4 ); +C_ASSERT( sizeof(w32_RenderModel_t_0912().unVertexCount) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_0912, rIndexData) == 8 ); +C_ASSERT( sizeof(w32_RenderModel_t_0912().rIndexData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_0912, unTriangleCount) == 12 ); +C_ASSERT( sizeof(w32_RenderModel_t_0912().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_0912, diffuseTextureId) == 16 ); +C_ASSERT( sizeof(w32_RenderModel_t_0912().diffuseTextureId) >= 4 ); + +C_ASSERT( sizeof(u32_RenderModel_t_0912) >= 20 ); +C_ASSERT( offsetof(u32_RenderModel_t_0912, rVertexData) == 0 ); +C_ASSERT( sizeof(u32_RenderModel_t_0912().rVertexData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_0912, unVertexCount) == 4 ); +C_ASSERT( sizeof(u32_RenderModel_t_0912().unVertexCount) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_0912, rIndexData) == 8 ); +C_ASSERT( sizeof(u32_RenderModel_t_0912().rIndexData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_0912, unTriangleCount) == 12 ); +C_ASSERT( sizeof(u32_RenderModel_t_0912().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_0912, diffuseTextureId) == 16 ); +C_ASSERT( sizeof(u32_RenderModel_t_0912().diffuseTextureId) >= 4 ); + +C_ASSERT( sizeof(w64_RenderModel_t_090) >= 56 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, ulInternalHandle) == 0 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().ulInternalHandle) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, rVertexData) == 8 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().rVertexData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, unVertexCount) == 16 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().unVertexCount) >= 4 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, rIndexData) == 24 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().rIndexData) >= 8 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, unTriangleCount) == 32 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(w64_RenderModel_t_090, diffuseTexture) == 40 ); +C_ASSERT( sizeof(w64_RenderModel_t_090().diffuseTexture) >= 16 ); + +C_ASSERT( sizeof(u64_RenderModel_t_090) >= 44 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, ulInternalHandle) == 0 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().ulInternalHandle) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, rVertexData) == 8 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().rVertexData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, unVertexCount) == 16 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().unVertexCount) >= 4 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, rIndexData) == 20 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().rIndexData) >= 8 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, unTriangleCount) == 28 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(u64_RenderModel_t_090, diffuseTexture) == 32 ); +C_ASSERT( sizeof(u64_RenderModel_t_090().diffuseTexture) >= 12 ); + +C_ASSERT( sizeof(w32_RenderModel_t_090) >= 32 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, ulInternalHandle) == 0 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().ulInternalHandle) >= 8 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, rVertexData) == 8 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().rVertexData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, unVertexCount) == 12 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().unVertexCount) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, rIndexData) == 16 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().rIndexData) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, unTriangleCount) == 20 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(w32_RenderModel_t_090, diffuseTexture) == 24 ); +C_ASSERT( sizeof(w32_RenderModel_t_090().diffuseTexture) >= 8 ); + +C_ASSERT( sizeof(u32_RenderModel_t_090) >= 32 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, ulInternalHandle) == 0 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().ulInternalHandle) >= 8 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, rVertexData) == 8 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().rVertexData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, unVertexCount) == 12 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().unVertexCount) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, rIndexData) == 16 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().rIndexData) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, unTriangleCount) == 20 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().unTriangleCount) >= 4 ); +C_ASSERT( offsetof(u32_RenderModel_t_090, diffuseTexture) == 24 ); +C_ASSERT( sizeof(u32_RenderModel_t_090().diffuseTexture) >= 8 ); + +C_ASSERT( sizeof(w64_VRControllerState001_t) >= 64 ); +C_ASSERT( offsetof(w64_VRControllerState001_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(w64_VRControllerState001_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(w64_VRControllerState001_t, ulButtonPressed) == 8 ); +C_ASSERT( sizeof(w64_VRControllerState001_t().ulButtonPressed) >= 8 ); +C_ASSERT( offsetof(w64_VRControllerState001_t, ulButtonTouched) == 16 ); +C_ASSERT( sizeof(w64_VRControllerState001_t().ulButtonTouched) >= 8 ); +C_ASSERT( offsetof(w64_VRControllerState001_t, rAxis) == 24 ); +C_ASSERT( sizeof(w64_VRControllerState001_t().rAxis) >= 40 ); + +C_ASSERT( sizeof(u64_VRControllerState001_t) >= 60 ); +C_ASSERT( offsetof(u64_VRControllerState001_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(u64_VRControllerState001_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(u64_VRControllerState001_t, ulButtonPressed) == 4 ); +C_ASSERT( sizeof(u64_VRControllerState001_t().ulButtonPressed) >= 8 ); +C_ASSERT( offsetof(u64_VRControllerState001_t, ulButtonTouched) == 12 ); +C_ASSERT( sizeof(u64_VRControllerState001_t().ulButtonTouched) >= 8 ); +C_ASSERT( offsetof(u64_VRControllerState001_t, rAxis) == 20 ); +C_ASSERT( sizeof(u64_VRControllerState001_t().rAxis) >= 40 ); + +C_ASSERT( sizeof(w32_VRControllerState001_t) >= 64 ); +C_ASSERT( offsetof(w32_VRControllerState001_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(w32_VRControllerState001_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(w32_VRControllerState001_t, ulButtonPressed) == 8 ); +C_ASSERT( sizeof(w32_VRControllerState001_t().ulButtonPressed) >= 8 ); +C_ASSERT( offsetof(w32_VRControllerState001_t, ulButtonTouched) == 16 ); +C_ASSERT( sizeof(w32_VRControllerState001_t().ulButtonTouched) >= 8 ); +C_ASSERT( offsetof(w32_VRControllerState001_t, rAxis) == 24 ); +C_ASSERT( sizeof(w32_VRControllerState001_t().rAxis) >= 40 ); + +C_ASSERT( sizeof(u32_VRControllerState001_t) >= 60 ); +C_ASSERT( offsetof(u32_VRControllerState001_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(u32_VRControllerState001_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(u32_VRControllerState001_t, ulButtonPressed) == 4 ); +C_ASSERT( sizeof(u32_VRControllerState001_t().ulButtonPressed) >= 8 ); +C_ASSERT( offsetof(u32_VRControllerState001_t, ulButtonTouched) == 12 ); +C_ASSERT( sizeof(u32_VRControllerState001_t().ulButtonTouched) >= 8 ); +C_ASSERT( offsetof(u32_VRControllerState001_t, rAxis) == 20 ); +C_ASSERT( sizeof(u32_VRControllerState001_t().rAxis) >= 40 ); + +C_ASSERT( sizeof(w64_VREvent_t_1168) >= 64 ); +C_ASSERT( offsetof(w64_VREvent_t_1168, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1168().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1168, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1168().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1168, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1168().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1168, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1168().data) >= 48 ); + +C_ASSERT( sizeof(u64_VREvent_t_1168) >= 60 ); +C_ASSERT( offsetof(u64_VREvent_t_1168, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1168().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1168, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1168().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1168, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1168().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1168, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1168().data) >= 48 ); + +C_ASSERT( sizeof(w32_VREvent_t_1168) >= 64 ); +C_ASSERT( offsetof(w32_VREvent_t_1168, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1168().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1168, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1168().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1168, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1168().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1168, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1168().data) >= 48 ); + +C_ASSERT( sizeof(u32_VREvent_t_1168) >= 60 ); +C_ASSERT( offsetof(u32_VREvent_t_1168, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1168().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1168, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1168().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1168, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1168().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1168, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1168().data) >= 48 ); + +C_ASSERT( sizeof(w64_VREvent_t_11030) >= 64 ); +C_ASSERT( offsetof(w64_VREvent_t_11030, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_11030().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_11030, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_11030().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_11030, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_11030().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_11030, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_11030().data) >= 48 ); + +C_ASSERT( sizeof(u64_VREvent_t_11030) >= 60 ); +C_ASSERT( offsetof(u64_VREvent_t_11030, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_11030().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_11030, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_11030().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_11030, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_11030().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_11030, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_11030().data) >= 48 ); + +C_ASSERT( sizeof(w32_VREvent_t_11030) >= 64 ); +C_ASSERT( offsetof(w32_VREvent_t_11030, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_11030().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_11030, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_11030().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_11030, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_11030().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_11030, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_11030().data) >= 48 ); + +C_ASSERT( sizeof(u32_VREvent_t_11030) >= 60 ); +C_ASSERT( offsetof(u32_VREvent_t_11030, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_11030().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_11030, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_11030().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_11030, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_11030().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_11030, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_11030().data) >= 48 ); + +C_ASSERT( sizeof(w64_VREvent_t_1322) >= 64 ); +C_ASSERT( offsetof(w64_VREvent_t_1322, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1322().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1322, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1322().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1322, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1322().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1322, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1322().data) >= 48 ); + +C_ASSERT( sizeof(u64_VREvent_t_1322) >= 60 ); +C_ASSERT( offsetof(u64_VREvent_t_1322, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1322().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1322, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1322().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1322, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1322().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1322, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1322().data) >= 48 ); + +C_ASSERT( sizeof(w32_VREvent_t_1322) >= 64 ); +C_ASSERT( offsetof(w32_VREvent_t_1322, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1322().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1322, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1322().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1322, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1322().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1322, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1322().data) >= 48 ); + +C_ASSERT( sizeof(u32_VREvent_t_1322) >= 60 ); +C_ASSERT( offsetof(u32_VREvent_t_1322, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1322().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1322, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1322().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1322, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1322().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1322, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1322().data) >= 48 ); + +C_ASSERT( sizeof(w64_VREvent_t_1210) >= 64 ); +C_ASSERT( offsetof(w64_VREvent_t_1210, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1210().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1210, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1210().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1210, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1210().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1210, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1210().data) >= 48 ); + +C_ASSERT( sizeof(u64_VREvent_t_1210) >= 60 ); +C_ASSERT( offsetof(u64_VREvent_t_1210, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1210().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1210, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1210().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1210, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1210().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1210, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1210().data) >= 48 ); + +C_ASSERT( sizeof(w32_VREvent_t_1210) >= 64 ); +C_ASSERT( offsetof(w32_VREvent_t_1210, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1210().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1210, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1210().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1210, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1210().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1210, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1210().data) >= 48 ); + +C_ASSERT( sizeof(u32_VREvent_t_1210) >= 60 ); +C_ASSERT( offsetof(u32_VREvent_t_1210, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1210().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1210, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1210().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1210, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1210().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1210, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1210().data) >= 48 ); + +C_ASSERT( sizeof(w64_VREvent_t_113b) >= 64 ); +C_ASSERT( offsetof(w64_VREvent_t_113b, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_113b().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_113b, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_113b().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_113b, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_113b().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_113b, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_113b().data) >= 48 ); + +C_ASSERT( sizeof(u64_VREvent_t_113b) >= 60 ); +C_ASSERT( offsetof(u64_VREvent_t_113b, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_113b().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_113b, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_113b().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_113b, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_113b().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_113b, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_113b().data) >= 48 ); + +C_ASSERT( sizeof(w32_VREvent_t_113b) >= 64 ); +C_ASSERT( offsetof(w32_VREvent_t_113b, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_113b().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_113b, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_113b().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_113b, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_113b().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_113b, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_113b().data) >= 48 ); + +C_ASSERT( sizeof(u32_VREvent_t_113b) >= 60 ); +C_ASSERT( offsetof(u32_VREvent_t_113b, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_113b().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_113b, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_113b().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_113b, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_113b().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_113b, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_113b().data) >= 48 ); + +C_ASSERT( sizeof(w64_VREvent_t_1016) >= 48 ); +C_ASSERT( offsetof(w64_VREvent_t_1016, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1016().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1016, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1016().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1016, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1016().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1016, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1016().data) >= 32 ); + +C_ASSERT( sizeof(u64_VREvent_t_1016) >= 44 ); +C_ASSERT( offsetof(u64_VREvent_t_1016, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1016().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1016, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1016().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1016, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1016().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1016, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1016().data) >= 32 ); + +C_ASSERT( sizeof(w32_VREvent_t_1016) >= 48 ); +C_ASSERT( offsetof(w32_VREvent_t_1016, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1016().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1016, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1016().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1016, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1016().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1016, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1016().data) >= 32 ); + +C_ASSERT( sizeof(u32_VREvent_t_1016) >= 44 ); +C_ASSERT( offsetof(u32_VREvent_t_1016, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1016().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1016, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1016().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1016, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1016().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1016, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1016().data) >= 32 ); + +C_ASSERT( sizeof(w64_VREvent_t_1015) >= 48 ); +C_ASSERT( offsetof(w64_VREvent_t_1015, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1015().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1015, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1015().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1015, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1015().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1015, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1015().data) >= 32 ); + +C_ASSERT( sizeof(u64_VREvent_t_1015) >= 44 ); +C_ASSERT( offsetof(u64_VREvent_t_1015, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1015().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1015, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1015().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1015, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1015().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1015, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1015().data) >= 32 ); + +C_ASSERT( sizeof(w32_VREvent_t_1015) >= 48 ); +C_ASSERT( offsetof(w32_VREvent_t_1015, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1015().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1015, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1015().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1015, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1015().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1015, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1015().data) >= 32 ); + +C_ASSERT( sizeof(u32_VREvent_t_1015) >= 44 ); +C_ASSERT( offsetof(u32_VREvent_t_1015, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1015().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1015, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1015().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1015, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1015().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1015, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1015().data) >= 32 ); + +C_ASSERT( sizeof(w64_VREvent_t_1014) >= 48 ); +C_ASSERT( offsetof(w64_VREvent_t_1014, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1014().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1014, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1014().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1014, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1014().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1014, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1014().data) >= 32 ); + +C_ASSERT( sizeof(u64_VREvent_t_1014) >= 44 ); +C_ASSERT( offsetof(u64_VREvent_t_1014, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1014().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1014, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1014().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1014, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1014().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1014, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1014().data) >= 32 ); + +C_ASSERT( sizeof(w32_VREvent_t_1014) >= 48 ); +C_ASSERT( offsetof(w32_VREvent_t_1014, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1014().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1014, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1014().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1014, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1014().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1014, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1014().data) >= 32 ); + +C_ASSERT( sizeof(u32_VREvent_t_1014) >= 44 ); +C_ASSERT( offsetof(u32_VREvent_t_1014, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1014().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1014, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1014().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1014, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1014().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1014, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1014().data) >= 32 ); + +C_ASSERT( sizeof(w64_VREvent_t_1013) >= 48 ); +C_ASSERT( offsetof(w64_VREvent_t_1013, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1013().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1013, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1013().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1013, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1013().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1013, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1013().data) >= 32 ); + +C_ASSERT( sizeof(u64_VREvent_t_1013) >= 44 ); +C_ASSERT( offsetof(u64_VREvent_t_1013, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1013().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1013, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1013().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1013, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1013().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1013, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1013().data) >= 32 ); + +C_ASSERT( sizeof(w32_VREvent_t_1013) >= 48 ); +C_ASSERT( offsetof(w32_VREvent_t_1013, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1013().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1013, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1013().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1013, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1013().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1013, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1013().data) >= 32 ); + +C_ASSERT( sizeof(u32_VREvent_t_1013) >= 44 ); +C_ASSERT( offsetof(u32_VREvent_t_1013, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1013().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1013, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1013().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1013, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1013().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1013, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1013().data) >= 32 ); + +C_ASSERT( sizeof(w64_VREvent_t_1012) >= 48 ); +C_ASSERT( offsetof(w64_VREvent_t_1012, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1012().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1012, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1012().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1012, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1012().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1012, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1012().data) >= 32 ); + +C_ASSERT( sizeof(u64_VREvent_t_1012) >= 44 ); +C_ASSERT( offsetof(u64_VREvent_t_1012, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1012().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1012, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1012().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1012, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1012().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1012, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1012().data) >= 32 ); + +C_ASSERT( sizeof(w32_VREvent_t_1012) >= 48 ); +C_ASSERT( offsetof(w32_VREvent_t_1012, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1012().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1012, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1012().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1012, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1012().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1012, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1012().data) >= 32 ); + +C_ASSERT( sizeof(u32_VREvent_t_1012) >= 40 ); +C_ASSERT( offsetof(u32_VREvent_t_1012, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1012().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1012, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1012().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1012, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1012().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1012, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1012().data) >= 28 ); + +C_ASSERT( sizeof(w64_VREvent_t_1011) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_1011, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_1011().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1011, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_1011().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1011, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_1011().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_1011, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_1011().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_1011) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_1011, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_1011().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1011, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_1011().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1011, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_1011().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_1011, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_1011().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_1011) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_1011, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_1011().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1011, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_1011().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1011, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_1011().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_1011, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_1011().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_1011) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_1011, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_1011().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1011, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_1011().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1011, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_1011().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_1011, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_1011().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_106) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_106, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_106().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_106, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_106().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_106, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_106().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_106, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_106().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_106) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_106, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_106().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_106, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_106().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_106, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_106().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_106, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_106().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_106) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_106, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_106().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_106, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_106().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_106, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_106().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_106, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_106().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_106) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_106, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_106().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_106, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_106().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_106, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_106().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_106, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_106().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_105) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_105, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_105().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_105, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_105().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_105, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_105().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_105, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_105().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_105) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_105, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_105().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_105, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_105().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_105, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_105().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_105, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_105().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_105) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_105, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_105().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_105, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_105().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_105, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_105().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_105, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_105().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_105) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_105, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_105().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_105, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_105().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_105, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_105().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_105, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_105().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_103) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_103, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_103().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_103, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_103().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_103, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_103().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_103, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_103().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_103) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_103, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_103().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_103, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_103().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_103, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_103().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_103, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_103().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_103) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_103, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_103().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_103, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_103().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_103, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_103().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_103, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_103().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_103) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_103, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_103().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_103, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_103().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_103, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_103().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_103, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_103().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_102) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_102, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_102().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_102, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_102().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_102, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_102().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_102, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_102().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_102) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_102, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_102().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_102, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_102().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_102, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_102().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_102, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_102().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_102) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_102, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_102().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_102, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_102().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_102, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_102().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_102, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_102().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_102) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_102, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_102().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_102, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_102().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_102, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_102().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_102, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_102().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_101) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_101, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_101().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_101, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_101().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_101, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_101().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_101, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_101().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_101) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_101, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_101().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_101, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_101().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_101, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_101().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_101, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_101().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_101) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_101, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_101().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_101, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_101().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_101, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_101().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_101, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_101().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_101) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_101, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_101().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_101, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_101().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_101, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_101().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_101, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_101().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_0918) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_0918, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_0918().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0918, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_0918().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0918, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_0918().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0918, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_0918().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_0918) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_0918, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_0918().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0918, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_0918().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0918, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_0918().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0918, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_0918().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_0918) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_0918, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_0918().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0918, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_0918().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0918, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_0918().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0918, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_0918().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_0918) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_0918, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_0918().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0918, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_0918().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0918, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_0918().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0918, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_0918().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_0915) >= 40 ); +C_ASSERT( offsetof(w64_VREvent_t_0915, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_0915().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0915, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_0915().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0915, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_0915().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0915, data) == 16 ); +C_ASSERT( sizeof(w64_VREvent_t_0915().data) >= 24 ); + +C_ASSERT( sizeof(u64_VREvent_t_0915) >= 36 ); +C_ASSERT( offsetof(u64_VREvent_t_0915, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_0915().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0915, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_0915().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0915, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_0915().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0915, data) == 12 ); +C_ASSERT( sizeof(u64_VREvent_t_0915().data) >= 24 ); + +C_ASSERT( sizeof(w32_VREvent_t_0915) >= 40 ); +C_ASSERT( offsetof(w32_VREvent_t_0915, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_0915().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0915, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_0915().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0915, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_0915().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0915, data) == 16 ); +C_ASSERT( sizeof(w32_VREvent_t_0915().data) >= 24 ); + +C_ASSERT( sizeof(u32_VREvent_t_0915) >= 36 ); +C_ASSERT( offsetof(u32_VREvent_t_0915, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_0915().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0915, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_0915().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0915, eventAgeSeconds) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_0915().eventAgeSeconds) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0915, data) == 12 ); +C_ASSERT( sizeof(u32_VREvent_t_0915().data) >= 24 ); + +C_ASSERT( sizeof(w64_VREvent_t_0914) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_0914, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_0914().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0914, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_0914().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0914, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_0914().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_0914, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_0914().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_0914) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_0914, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_0914().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0914, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_0914().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0914, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_0914().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_0914, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_0914().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_0914) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_0914, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_0914().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0914, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_0914().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0914, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_0914().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_0914, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_0914().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_0914) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_0914, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_0914().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0914, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_0914().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0914, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_0914().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_0914, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_0914().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_0912) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_0912, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_0912().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0912, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_0912().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0912, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_0912().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_0912, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_0912().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_0912) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_0912, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_0912().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0912, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_0912().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0912, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_0912().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_0912, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_0912().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_0912) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_0912, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_0912().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0912, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_0912().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0912, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_0912().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_0912, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_0912().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_0912) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_0912, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_0912().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0912, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_0912().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0912, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_0912().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_0912, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_0912().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_0910) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_0910, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_0910().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0910, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_0910().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_0910, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_0910().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_0910, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_0910().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_0910) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_0910, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_0910().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0910, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_0910().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_0910, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_0910().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_0910, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_0910().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_0910) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_0910, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_0910().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0910, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_0910().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_0910, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_0910().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_0910, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_0910().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_0910) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_0910, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_0910().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0910, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_0910().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_0910, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_0910().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_0910, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_0910().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_097) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_097, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_097().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_097, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_097().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_097, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_097().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_097, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_097().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_097) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_097, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_097().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_097, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_097().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_097, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_097().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_097, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_097().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_097) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_097, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_097().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_097, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_097().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_097, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_097().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_097, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_097().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_097) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_097, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_097().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_097, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_097().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_097, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_097().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_097, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_097().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_093) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_093, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_093().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_093, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_093().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_093, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_093().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_093, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_093().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_093) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_093, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_093().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_093, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_093().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_093, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_093().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_093, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_093().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_093) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_093, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_093().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_093, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_093().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_093, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_093().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_093, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_093().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_093) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_093, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_093().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_093, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_093().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_093, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_093().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_093, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_093().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_092) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_092, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_092().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_092, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_092().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_092, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_092().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_092, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_092().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_092) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_092, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_092().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_092, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_092().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_092, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_092().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_092, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_092().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_092) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_092, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_092().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_092, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_092().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_092, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_092().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_092, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_092().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_092) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_092, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_092().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_092, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_092().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_092, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_092().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_092, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_092().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VREvent_t_090) >= 32 ); +C_ASSERT( offsetof(w64_VREvent_t_090, eventType) == 0 ); +C_ASSERT( sizeof(w64_VREvent_t_090().eventType) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_090, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w64_VREvent_t_090().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w64_VREvent_t_090, data) == 8 ); +C_ASSERT( sizeof(w64_VREvent_t_090().data) >= 16 ); +C_ASSERT( offsetof(w64_VREvent_t_090, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w64_VREvent_t_090().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u64_VREvent_t_090) >= 28 ); +C_ASSERT( offsetof(u64_VREvent_t_090, eventType) == 0 ); +C_ASSERT( sizeof(u64_VREvent_t_090().eventType) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_090, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u64_VREvent_t_090().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u64_VREvent_t_090, data) == 8 ); +C_ASSERT( sizeof(u64_VREvent_t_090().data) >= 16 ); +C_ASSERT( offsetof(u64_VREvent_t_090, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u64_VREvent_t_090().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w32_VREvent_t_090) >= 32 ); +C_ASSERT( offsetof(w32_VREvent_t_090, eventType) == 0 ); +C_ASSERT( sizeof(w32_VREvent_t_090().eventType) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_090, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(w32_VREvent_t_090().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(w32_VREvent_t_090, data) == 8 ); +C_ASSERT( sizeof(w32_VREvent_t_090().data) >= 16 ); +C_ASSERT( offsetof(w32_VREvent_t_090, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(w32_VREvent_t_090().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(u32_VREvent_t_090) >= 28 ); +C_ASSERT( offsetof(u32_VREvent_t_090, eventType) == 0 ); +C_ASSERT( sizeof(u32_VREvent_t_090().eventType) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_090, trackedDeviceIndex) == 4 ); +C_ASSERT( sizeof(u32_VREvent_t_090().trackedDeviceIndex) >= 4 ); +C_ASSERT( offsetof(u32_VREvent_t_090, data) == 8 ); +C_ASSERT( sizeof(u32_VREvent_t_090().data) >= 16 ); +C_ASSERT( offsetof(u32_VREvent_t_090, eventAgeSeconds) == 24 ); +C_ASSERT( sizeof(u32_VREvent_t_090().eventAgeSeconds) >= 4 ); + +C_ASSERT( sizeof(w64_VRNativeDevice_t) >= 16 ); +C_ASSERT( offsetof(w64_VRNativeDevice_t, handle) == 0 ); +C_ASSERT( sizeof(w64_VRNativeDevice_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_VRNativeDevice_t, eType) == 8 ); +C_ASSERT( sizeof(w64_VRNativeDevice_t().eType) >= 4 ); + +C_ASSERT( sizeof(u64_VRNativeDevice_t) >= 16 ); +C_ASSERT( offsetof(u64_VRNativeDevice_t, handle) == 0 ); +C_ASSERT( sizeof(u64_VRNativeDevice_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_VRNativeDevice_t, eType) == 8 ); +C_ASSERT( sizeof(u64_VRNativeDevice_t().eType) >= 4 ); + +C_ASSERT( sizeof(w32_VRNativeDevice_t) >= 8 ); +C_ASSERT( offsetof(w32_VRNativeDevice_t, handle) == 0 ); +C_ASSERT( sizeof(w32_VRNativeDevice_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_VRNativeDevice_t, eType) == 4 ); +C_ASSERT( sizeof(w32_VRNativeDevice_t().eType) >= 4 ); + +C_ASSERT( sizeof(u32_VRNativeDevice_t) >= 8 ); +C_ASSERT( offsetof(u32_VRNativeDevice_t, handle) == 0 ); +C_ASSERT( sizeof(u32_VRNativeDevice_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_VRNativeDevice_t, eType) == 4 ); +C_ASSERT( sizeof(u32_VRNativeDevice_t().eType) >= 4 ); + +C_ASSERT( sizeof(w64_VROverlayView_t) >= 40 ); +C_ASSERT( offsetof(w64_VROverlayView_t, overlayHandle) == 0 ); +C_ASSERT( sizeof(w64_VROverlayView_t().overlayHandle) >= 8 ); +C_ASSERT( offsetof(w64_VROverlayView_t, texture) == 8 ); +C_ASSERT( sizeof(w64_VROverlayView_t().texture) >= 16 ); +C_ASSERT( offsetof(w64_VROverlayView_t, textureBounds) == 24 ); +C_ASSERT( sizeof(w64_VROverlayView_t().textureBounds) >= 16 ); + +C_ASSERT( sizeof(u64_VROverlayView_t) >= 40 ); +C_ASSERT( offsetof(u64_VROverlayView_t, overlayHandle) == 0 ); +C_ASSERT( sizeof(u64_VROverlayView_t().overlayHandle) >= 8 ); +C_ASSERT( offsetof(u64_VROverlayView_t, texture) == 8 ); +C_ASSERT( sizeof(u64_VROverlayView_t().texture) >= 16 ); +C_ASSERT( offsetof(u64_VROverlayView_t, textureBounds) == 24 ); +C_ASSERT( sizeof(u64_VROverlayView_t().textureBounds) >= 16 ); + +C_ASSERT( sizeof(w32_VROverlayView_t) >= 40 ); +C_ASSERT( offsetof(w32_VROverlayView_t, overlayHandle) == 0 ); +C_ASSERT( sizeof(w32_VROverlayView_t().overlayHandle) >= 8 ); +C_ASSERT( offsetof(w32_VROverlayView_t, texture) == 8 ); +C_ASSERT( sizeof(w32_VROverlayView_t().texture) >= 12 ); +C_ASSERT( offsetof(w32_VROverlayView_t, textureBounds) == 20 ); +C_ASSERT( sizeof(w32_VROverlayView_t().textureBounds) >= 16 ); + +C_ASSERT( sizeof(u32_VROverlayView_t) >= 36 ); +C_ASSERT( offsetof(u32_VROverlayView_t, overlayHandle) == 0 ); +C_ASSERT( sizeof(u32_VROverlayView_t().overlayHandle) >= 8 ); +C_ASSERT( offsetof(u32_VROverlayView_t, texture) == 8 ); +C_ASSERT( sizeof(u32_VROverlayView_t().texture) >= 12 ); +C_ASSERT( offsetof(u32_VROverlayView_t, textureBounds) == 20 ); +C_ASSERT( sizeof(u32_VROverlayView_t().textureBounds) >= 16 ); + +C_ASSERT( sizeof(w64_VRTextureWithDepth_t) >= 96 ); +C_ASSERT( offsetof(w64_VRTextureWithDepth_t, handle) == 0 ); +C_ASSERT( sizeof(w64_VRTextureWithDepth_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_VRTextureWithDepth_t, eType) == 8 ); +C_ASSERT( sizeof(w64_VRTextureWithDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithDepth_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(w64_VRTextureWithDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithDepth_t, depth) == 16 ); +C_ASSERT( sizeof(w64_VRTextureWithDepth_t().depth) >= 80 ); + +C_ASSERT( sizeof(u64_VRTextureWithDepth_t) >= 96 ); +C_ASSERT( offsetof(u64_VRTextureWithDepth_t, handle) == 0 ); +C_ASSERT( sizeof(u64_VRTextureWithDepth_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_VRTextureWithDepth_t, eType) == 8 ); +C_ASSERT( sizeof(u64_VRTextureWithDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithDepth_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(u64_VRTextureWithDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithDepth_t, depth) == 16 ); +C_ASSERT( sizeof(u64_VRTextureWithDepth_t().depth) >= 80 ); + +C_ASSERT( sizeof(w32_VRTextureWithDepth_t) >= 88 ); +C_ASSERT( offsetof(w32_VRTextureWithDepth_t, handle) == 0 ); +C_ASSERT( sizeof(w32_VRTextureWithDepth_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithDepth_t, eType) == 4 ); +C_ASSERT( sizeof(w32_VRTextureWithDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithDepth_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(w32_VRTextureWithDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithDepth_t, depth) == 12 ); +C_ASSERT( sizeof(w32_VRTextureWithDepth_t().depth) >= 76 ); + +C_ASSERT( sizeof(u32_VRTextureWithDepth_t) >= 88 ); +C_ASSERT( offsetof(u32_VRTextureWithDepth_t, handle) == 0 ); +C_ASSERT( sizeof(u32_VRTextureWithDepth_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithDepth_t, eType) == 4 ); +C_ASSERT( sizeof(u32_VRTextureWithDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithDepth_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(u32_VRTextureWithDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithDepth_t, depth) == 12 ); +C_ASSERT( sizeof(u32_VRTextureWithDepth_t().depth) >= 76 ); + +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t) >= 144 ); +C_ASSERT( offsetof(w64_VRTextureWithPoseAndDepth_t, handle) == 0 ); +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_VRTextureWithPoseAndDepth_t, eType) == 8 ); +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithPoseAndDepth_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithPoseAndDepth_t, mDeviceToAbsoluteTracking) == 16 ); +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t().mDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w64_VRTextureWithPoseAndDepth_t, depth) == 64 ); +C_ASSERT( sizeof(w64_VRTextureWithPoseAndDepth_t().depth) >= 80 ); + +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t) >= 144 ); +C_ASSERT( offsetof(u64_VRTextureWithPoseAndDepth_t, handle) == 0 ); +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_VRTextureWithPoseAndDepth_t, eType) == 8 ); +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithPoseAndDepth_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithPoseAndDepth_t, mDeviceToAbsoluteTracking) == 16 ); +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t().mDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u64_VRTextureWithPoseAndDepth_t, depth) == 64 ); +C_ASSERT( sizeof(u64_VRTextureWithPoseAndDepth_t().depth) >= 80 ); + +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t) >= 136 ); +C_ASSERT( offsetof(w32_VRTextureWithPoseAndDepth_t, handle) == 0 ); +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPoseAndDepth_t, eType) == 4 ); +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPoseAndDepth_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPoseAndDepth_t, mDeviceToAbsoluteTracking) == 12 ); +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t().mDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(w32_VRTextureWithPoseAndDepth_t, depth) == 60 ); +C_ASSERT( sizeof(w32_VRTextureWithPoseAndDepth_t().depth) >= 76 ); + +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t) >= 136 ); +C_ASSERT( offsetof(u32_VRTextureWithPoseAndDepth_t, handle) == 0 ); +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPoseAndDepth_t, eType) == 4 ); +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t().eType) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPoseAndDepth_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPoseAndDepth_t, mDeviceToAbsoluteTracking) == 12 ); +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t().mDeviceToAbsoluteTracking) >= 48 ); +C_ASSERT( offsetof(u32_VRTextureWithPoseAndDepth_t, depth) == 60 ); +C_ASSERT( sizeof(u32_VRTextureWithPoseAndDepth_t().depth) >= 76 ); + +C_ASSERT( sizeof(w64_VRTextureWithPose_t) >= 64 ); +C_ASSERT( offsetof(w64_VRTextureWithPose_t, handle) == 0 ); +C_ASSERT( sizeof(w64_VRTextureWithPose_t().handle) >= 8 ); +C_ASSERT( offsetof(w64_VRTextureWithPose_t, eType) == 8 ); +C_ASSERT( sizeof(w64_VRTextureWithPose_t().eType) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithPose_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(w64_VRTextureWithPose_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w64_VRTextureWithPose_t, mDeviceToAbsoluteTracking) == 16 ); +C_ASSERT( sizeof(w64_VRTextureWithPose_t().mDeviceToAbsoluteTracking) >= 48 ); + +C_ASSERT( sizeof(u64_VRTextureWithPose_t) >= 64 ); +C_ASSERT( offsetof(u64_VRTextureWithPose_t, handle) == 0 ); +C_ASSERT( sizeof(u64_VRTextureWithPose_t().handle) >= 8 ); +C_ASSERT( offsetof(u64_VRTextureWithPose_t, eType) == 8 ); +C_ASSERT( sizeof(u64_VRTextureWithPose_t().eType) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithPose_t, eColorSpace) == 12 ); +C_ASSERT( sizeof(u64_VRTextureWithPose_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u64_VRTextureWithPose_t, mDeviceToAbsoluteTracking) == 16 ); +C_ASSERT( sizeof(u64_VRTextureWithPose_t().mDeviceToAbsoluteTracking) >= 48 ); + +C_ASSERT( sizeof(w32_VRTextureWithPose_t) >= 60 ); +C_ASSERT( offsetof(w32_VRTextureWithPose_t, handle) == 0 ); +C_ASSERT( sizeof(w32_VRTextureWithPose_t().handle) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPose_t, eType) == 4 ); +C_ASSERT( sizeof(w32_VRTextureWithPose_t().eType) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPose_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(w32_VRTextureWithPose_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(w32_VRTextureWithPose_t, mDeviceToAbsoluteTracking) == 12 ); +C_ASSERT( sizeof(w32_VRTextureWithPose_t().mDeviceToAbsoluteTracking) >= 48 ); + +C_ASSERT( sizeof(u32_VRTextureWithPose_t) >= 60 ); +C_ASSERT( offsetof(u32_VRTextureWithPose_t, handle) == 0 ); +C_ASSERT( sizeof(u32_VRTextureWithPose_t().handle) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPose_t, eType) == 4 ); +C_ASSERT( sizeof(u32_VRTextureWithPose_t().eType) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPose_t, eColorSpace) == 8 ); +C_ASSERT( sizeof(u32_VRTextureWithPose_t().eColorSpace) >= 4 ); +C_ASSERT( offsetof(u32_VRTextureWithPose_t, mDeviceToAbsoluteTracking) == 12 ); +C_ASSERT( sizeof(u32_VRTextureWithPose_t().mDeviceToAbsoluteTracking) >= 48 ); + +C_ASSERT( sizeof(w64_VRVulkanDevice_t) >= 40 ); +C_ASSERT( offsetof(w64_VRVulkanDevice_t, m_pInstance) == 0 ); +C_ASSERT( sizeof(w64_VRVulkanDevice_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanDevice_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w64_VRVulkanDevice_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanDevice_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(w64_VRVulkanDevice_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanDevice_t, m_pQueue) == 24 ); +C_ASSERT( sizeof(w64_VRVulkanDevice_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanDevice_t, m_uQueueFamilyIndex) == 32 ); +C_ASSERT( sizeof(w64_VRVulkanDevice_t().m_uQueueFamilyIndex) >= 4 ); + +C_ASSERT( sizeof(u64_VRVulkanDevice_t) >= 40 ); +C_ASSERT( offsetof(u64_VRVulkanDevice_t, m_pInstance) == 0 ); +C_ASSERT( sizeof(u64_VRVulkanDevice_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanDevice_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u64_VRVulkanDevice_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanDevice_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(u64_VRVulkanDevice_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanDevice_t, m_pQueue) == 24 ); +C_ASSERT( sizeof(u64_VRVulkanDevice_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanDevice_t, m_uQueueFamilyIndex) == 32 ); +C_ASSERT( sizeof(u64_VRVulkanDevice_t().m_uQueueFamilyIndex) >= 4 ); + +C_ASSERT( sizeof(w32_VRVulkanDevice_t) >= 20 ); +C_ASSERT( offsetof(w32_VRVulkanDevice_t, m_pInstance) == 0 ); +C_ASSERT( sizeof(w32_VRVulkanDevice_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanDevice_t, m_pDevice) == 4 ); +C_ASSERT( sizeof(w32_VRVulkanDevice_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanDevice_t, m_pPhysicalDevice) == 8 ); +C_ASSERT( sizeof(w32_VRVulkanDevice_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanDevice_t, m_pQueue) == 12 ); +C_ASSERT( sizeof(w32_VRVulkanDevice_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanDevice_t, m_uQueueFamilyIndex) == 16 ); +C_ASSERT( sizeof(w32_VRVulkanDevice_t().m_uQueueFamilyIndex) >= 4 ); + +C_ASSERT( sizeof(u32_VRVulkanDevice_t) >= 20 ); +C_ASSERT( offsetof(u32_VRVulkanDevice_t, m_pInstance) == 0 ); +C_ASSERT( sizeof(u32_VRVulkanDevice_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanDevice_t, m_pDevice) == 4 ); +C_ASSERT( sizeof(u32_VRVulkanDevice_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanDevice_t, m_pPhysicalDevice) == 8 ); +C_ASSERT( sizeof(u32_VRVulkanDevice_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanDevice_t, m_pQueue) == 12 ); +C_ASSERT( sizeof(u32_VRVulkanDevice_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanDevice_t, m_uQueueFamilyIndex) == 16 ); +C_ASSERT( sizeof(u32_VRVulkanDevice_t().m_uQueueFamilyIndex) >= 4 ); + +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t) >= 72 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_nSampleCount) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_unArrayIndex) == 64 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_unArrayIndex) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureArrayData_t, m_unArraySize) == 68 ); +C_ASSERT( sizeof(w64_VRVulkanTextureArrayData_t().m_unArraySize) >= 4 ); + +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t) >= 72 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_nSampleCount) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_unArrayIndex) == 64 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_unArrayIndex) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureArrayData_t, m_unArraySize) == 68 ); +C_ASSERT( sizeof(u64_VRVulkanTextureArrayData_t().m_unArraySize) >= 4 ); + +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t) >= 56 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_nSampleCount) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_unArrayIndex) == 48 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_unArrayIndex) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureArrayData_t, m_unArraySize) == 52 ); +C_ASSERT( sizeof(w32_VRVulkanTextureArrayData_t().m_unArraySize) >= 4 ); + +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t) >= 52 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_nSampleCount) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_unArrayIndex) == 44 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_unArrayIndex) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureArrayData_t, m_unArraySize) == 48 ); +C_ASSERT( sizeof(u32_VRVulkanTextureArrayData_t().m_unArraySize) >= 4 ); + +C_ASSERT( sizeof(w64_VRVulkanTextureData_t) >= 64 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w64_VRVulkanTextureData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(w64_VRVulkanTextureData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(u64_VRVulkanTextureData_t) >= 64 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u64_VRVulkanTextureData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(u64_VRVulkanTextureData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(w32_VRVulkanTextureData_t) >= 48 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w32_VRVulkanTextureData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(w32_VRVulkanTextureData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(u32_VRVulkanTextureData_t) >= 44 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u32_VRVulkanTextureData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(u32_VRVulkanTextureData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(w64_VulkanData_t) >= 64 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w64_VulkanData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(w64_VulkanData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(u64_VulkanData_t) >= 60 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_pDevice) >= 8 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_pPhysicalDevice) == 16 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_pPhysicalDevice) >= 8 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_pInstance) == 24 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_pInstance) >= 8 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_pQueue) == 32 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_pQueue) >= 8 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nQueueFamilyIndex) == 40 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nWidth) == 44 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nHeight) == 48 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nFormat) == 52 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u64_VulkanData_t, m_nSampleCount) == 56 ); +C_ASSERT( sizeof(u64_VulkanData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(w32_VulkanData_t) >= 48 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(w32_VulkanData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(w32_VulkanData_t().m_nSampleCount) >= 4 ); + +C_ASSERT( sizeof(u32_VulkanData_t) >= 44 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nImage) == 0 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nImage) >= 8 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_pDevice) == 8 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_pDevice) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_pPhysicalDevice) == 12 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_pPhysicalDevice) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_pInstance) == 16 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_pInstance) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_pQueue) == 20 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_pQueue) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nQueueFamilyIndex) == 24 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nQueueFamilyIndex) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nWidth) == 28 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nWidth) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nHeight) == 32 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nHeight) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nFormat) == 36 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nFormat) >= 4 ); +C_ASSERT( offsetof(u32_VulkanData_t, m_nSampleCount) == 40 ); +C_ASSERT( sizeof(u32_VulkanData_t().m_nSampleCount) >= 4 ); + diff --git a/vrclient_x64/vrclient_x64/vrclient_structs.h b/vrclient_x64/vrclient_x64/vrclient_structs.h new file mode 100644 index 00000000..a0f52426 --- /dev/null +++ b/vrclient_x64/vrclient_x64/vrclient_structs.h @@ -0,0 +1,100 @@ +#include +#include +#include +#include + +#include +#include + +#ifdef __cplusplus +#include +extern "C" +{ +#endif /* __cplusplus */ + +#ifdef __cplusplus +#define U64_ARRAY( type, count, name ) std::array name +#define U32_ARRAY( type, count, name ) std::array name +#define W64_ARRAY( type, count, name ) std::array name +#define W32_ARRAY( type, count, name ) std::array name +#else +#define U64_ARRAY( type, count, name ) type name[count] +#define U32_ARRAY( type, count, name ) type name[count] +#define W64_ARRAY( type, count, name ) type name[count] +#define W32_ARRAY( type, count, name ) type name[count] +#endif + +#define W_CDECL __cdecl +#define W_STDCALL __stdcall +#define U_CDECL __attribute__((sysv_abi)) +#define U_STDCALL __attribute__((sysv_abi)) + +#ifdef __i386__ +#define U64_PTR( decl, name ) uint64_t name +#define U32_PTR( decl, name ) decl +#define W64_PTR( decl, name ) uint64_t name +#define W32_PTR( decl, name ) decl +#define U_PTR U32_PTR +#define W_PTR W32_PTR +#endif + +#ifdef __x86_64__ +#define U64_PTR( decl, name ) decl +#define U32_PTR( decl, name ) uint32_t name +#define W64_PTR( decl, name ) decl +#define W32_PTR( decl, name ) uint32_t name +#define U_PTR U64_PTR +#define W_PTR W64_PTR +#endif + +typedef struct HmdColor_t HmdColor_t; +typedef struct HmdMatrix33_t HmdMatrix33_t; +typedef struct HmdMatrix34_t HmdMatrix34_t; +typedef struct HmdMatrix44_t HmdMatrix44_t; +typedef struct HmdQuad_t HmdQuad_t; +typedef struct HmdQuaternion_t HmdQuaternion_t; +typedef struct HmdQuaternionf_t HmdQuaternionf_t; +typedef struct HmdVector2_t HmdVector2_t; +typedef struct HmdVector3_t HmdVector3_t; +typedef struct HmdVector3d_t HmdVector3d_t; +typedef struct HmdVector4_t HmdVector4_t; + +struct HmdColor_t { float r, g, b, a; }; +struct HmdMatrix33_t { float m[3][4]; }; +struct HmdMatrix34_t { float m[3][4]; }; +struct HmdMatrix44_t { float m[4][4]; }; +struct HmdQuaternion_t { double w, x, y, z; }; +struct HmdQuaternionf_t { float w, x, y, z; }; +struct HmdVector2_t { float v[2]; }; +struct HmdVector3_t { float v[3]; }; +struct HmdVector3d_t { double v[3]; }; +struct HmdVector4_t { float v[4]; }; +struct HmdQuad_t { HmdVector3_t vCorners[4]; }; + +typedef struct IntersectionMaskRectangle_t IntersectionMaskRectangle_t; +struct IntersectionMaskRectangle_t +{ + float m_flTopLeftX; + float m_flTopLeftY; + float m_flWidth; + float m_flHeight; +}; + +typedef struct IntersectionMaskCircle_t IntersectionMaskCircle_t; +struct IntersectionMaskCircle_t +{ + float m_flCenterX; + float m_flCenterY; + float m_flRadius; +}; + +typedef struct VkDevice_T VkDevice_T; +typedef struct VkInstance_T VkInstance_T; +typedef struct VkPhysicalDevice_T VkPhysicalDevice_T; +typedef struct VkQueue_T VkQueue_T; + +#include "vrclient_structs_generated.h" + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ diff --git a/vrclient_x64/vrclient_x64/vrclient_structs_generated.h b/vrclient_x64/vrclient_x64/vrclient_structs_generated.h new file mode 100644 index 00000000..9dc8ecf9 --- /dev/null +++ b/vrclient_x64/vrclient_x64/vrclient_structs_generated.h @@ -0,0 +1,5734 @@ +typedef struct VREvent_ApplicationLaunch_t VREvent_ApplicationLaunch_t; +#pragma pack( push, 4 ) +struct VREvent_ApplicationLaunch_t +{ + uint32_t pid; + uint32_t unArgsHandle; +}; +#pragma pack( pop ) + +typedef struct VREvent_Chaperone_t VREvent_Chaperone_t; +#pragma pack( push, 8 ) +struct VREvent_Chaperone_t +{ + uint64_t m_nPreviousUniverse; + uint64_t m_nCurrentUniverse; +}; +#pragma pack( pop ) + +typedef struct VREvent_Controller_t VREvent_Controller_t; +#pragma pack( push, 4 ) +struct VREvent_Controller_t +{ + uint32_t button; +}; +#pragma pack( pop ) + +typedef struct VREvent_DualAnalog_t VREvent_DualAnalog_t; +#pragma pack( push, 4 ) +struct VREvent_DualAnalog_t +{ + float x; + float y; + float transformedX; + float transformedY; + uint32_t which; +}; +#pragma pack( pop ) + +typedef struct VREvent_EditingCameraSurface_t VREvent_EditingCameraSurface_t; +#pragma pack( push, 8 ) +struct VREvent_EditingCameraSurface_t +{ + uint64_t overlayHandle; + uint32_t nVisualMode; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct VREvent_HDCPError_t VREvent_HDCPError_t; +#pragma pack( push, 4 ) +struct VREvent_HDCPError_t +{ + uint32_t eCode; +}; +#pragma pack( pop ) + +typedef struct VREvent_HapticVibration_t VREvent_HapticVibration_t; +#pragma pack( push, 8 ) +struct VREvent_HapticVibration_t +{ + uint64_t containerHandle; + uint64_t componentHandle; + float fDurationSeconds; + float fFrequency; + float fAmplitude; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +typedef struct VREvent_InputActionManifestLoad_t VREvent_InputActionManifestLoad_t; +#pragma pack( push, 8 ) +struct VREvent_InputActionManifestLoad_t +{ + uint64_t pathAppKey; + uint64_t pathMessage; + uint64_t pathMessageParam; + uint64_t pathManifestPath; +}; +#pragma pack( pop ) + +typedef struct VREvent_InputBindingLoad_t_1016 VREvent_InputBindingLoad_t_1016; +#pragma pack( push, 8 ) +struct VREvent_InputBindingLoad_t_1016 +{ + uint64_t ulAppContainer; + uint64_t pathMessage; + uint64_t pathUrl; + uint64_t pathControllerType; +}; +#pragma pack( pop ) + +typedef struct VREvent_InputBindingLoad_t_1015 VREvent_InputBindingLoad_t_1015; +#pragma pack( push, 8 ) +struct VREvent_InputBindingLoad_t_1015 +{ + uint64_t ulAppContainer; + uint64_t pathMessage; + uint64_t pathUrl; +}; +#pragma pack( pop ) + +typedef struct VREvent_Ipd_t VREvent_Ipd_t; +#pragma pack( push, 4 ) +struct VREvent_Ipd_t +{ + float ipdMeters; +}; +#pragma pack( pop ) + +typedef struct VREvent_Keyboard_t_0912 VREvent_Keyboard_t_0912; +#pragma pack( push, 8 ) +struct VREvent_Keyboard_t_0912 +{ + char (cNewInput)[8]; + uint64_t uUserValue; +}; +#pragma pack( pop ) + +typedef struct VREvent_Keyboard_t_0910 VREvent_Keyboard_t_0910; +#pragma pack( push, 4 ) +struct VREvent_Keyboard_t_0910 +{ + char (cNewInput)[12]; + uint32_t uFlags; +}; +#pragma pack( pop ) + +typedef struct VREvent_MessageOverlay_t VREvent_MessageOverlay_t; +#pragma pack( push, 4 ) +struct VREvent_MessageOverlay_t +{ + uint32_t unVRMessageOverlayResponse; +}; +#pragma pack( pop ) + +typedef struct VREvent_Mouse_t VREvent_Mouse_t; +#pragma pack( push, 4 ) +struct VREvent_Mouse_t +{ + float x; + float y; + uint32_t button; +}; +#pragma pack( pop ) + +typedef struct VREvent_Notification_t_093 VREvent_Notification_t_093; +#pragma pack( push, 8 ) +struct VREvent_Notification_t_093 +{ + uint64_t ulUserValue; + uint32_t notificationId; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct VREvent_Notification_t_092 VREvent_Notification_t_092; +#pragma pack( push, 4 ) +struct VREvent_Notification_t_092 +{ + float x; + float y; + uint32_t notificationId; +}; +#pragma pack( pop ) + +typedef struct VREvent_Overlay_t_1168 VREvent_Overlay_t_1168; +#pragma pack( push, 8 ) +struct VREvent_Overlay_t_1168 +{ + uint64_t overlayHandle; + uint64_t devicePath; + uint64_t memoryBlockId; +}; +#pragma pack( pop ) + +typedef struct VREvent_Overlay_t_1014 VREvent_Overlay_t_1014; +#pragma pack( push, 8 ) +struct VREvent_Overlay_t_1014 +{ + uint64_t overlayHandle; + uint64_t devicePath; +}; +#pragma pack( pop ) + +typedef struct VREvent_Overlay_t_092 VREvent_Overlay_t_092; +#pragma pack( push, 8 ) +struct VREvent_Overlay_t_092 +{ + uint64_t overlayHandle; +}; +#pragma pack( pop ) + +typedef struct VREvent_PerformanceTest_t VREvent_PerformanceTest_t; +#pragma pack( push, 4 ) +struct VREvent_PerformanceTest_t +{ + uint32_t m_nFidelityLevel; +}; +#pragma pack( pop ) + +typedef struct VREvent_Process_t_1210 VREvent_Process_t_1210; +#pragma pack( push, 4 ) +struct VREvent_Process_t_1210 +{ + uint32_t pid; + uint32_t oldPid; + bool bForced; + bool bConnectionLost; + uint8_t __pad_10[2]; +}; +#pragma pack( pop ) + +typedef struct VREvent_Process_t_0912 VREvent_Process_t_0912; +#pragma pack( push, 4 ) +struct VREvent_Process_t_0912 +{ + uint32_t pid; + uint32_t oldPid; + bool bForced; + uint8_t __pad_9[3]; +}; +#pragma pack( pop ) + +typedef struct VREvent_Process_t_090 VREvent_Process_t_090; +#pragma pack( push, 4 ) +struct VREvent_Process_t_090 +{ + uint32_t pid; + uint32_t oldPid; +}; +#pragma pack( pop ) + +typedef struct VREvent_ProgressUpdate_t VREvent_ProgressUpdate_t; +#pragma pack( push, 8 ) +struct VREvent_ProgressUpdate_t +{ + uint64_t ulApplicationPropertyContainer; + uint64_t pathDevice; + uint64_t pathInputSource; + uint64_t pathProgressAction; + uint64_t pathIcon; + float fProgress; + uint8_t __pad_44[4]; +}; +#pragma pack( pop ) + +typedef struct VREvent_Property_t VREvent_Property_t; +#pragma pack( push, 8 ) +struct VREvent_Property_t +{ + uint64_t container; + uint32_t prop; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct VREvent_Reserved_t_113b VREvent_Reserved_t_113b; +#pragma pack( push, 8 ) +struct VREvent_Reserved_t_113b +{ + uint64_t reserved0; + uint64_t reserved1; + uint64_t reserved2; + uint64_t reserved3; + uint64_t reserved4; + uint64_t reserved5; +}; +#pragma pack( pop ) + +typedef struct VREvent_Reserved_t_1013 VREvent_Reserved_t_1013; +#pragma pack( push, 8 ) +struct VREvent_Reserved_t_1013 +{ + uint64_t reserved0; + uint64_t reserved1; + uint64_t reserved2; + uint64_t reserved3; +}; +#pragma pack( pop ) + +typedef struct VREvent_Reserved_t_090 VREvent_Reserved_t_090; +#pragma pack( push, 8 ) +struct VREvent_Reserved_t_090 +{ + uint64_t reserved0; + uint64_t reserved1; +}; +#pragma pack( pop ) + +typedef struct VREvent_ScreenshotProgress_t VREvent_ScreenshotProgress_t; +#pragma pack( push, 4 ) +struct VREvent_ScreenshotProgress_t +{ + float progress; +}; +#pragma pack( pop ) + +typedef struct VREvent_Screenshot_t VREvent_Screenshot_t; +#pragma pack( push, 4 ) +struct VREvent_Screenshot_t +{ + uint32_t handle; + uint32_t type; +}; +#pragma pack( pop ) + +typedef struct VREvent_Scroll_t_1322 VREvent_Scroll_t_1322; +#pragma pack( push, 4 ) +struct VREvent_Scroll_t_1322 +{ + float xdelta; + float ydelta; + uint32_t unused; + float viewportscale; +}; +#pragma pack( pop ) + +typedef struct VREvent_Scroll_t_0915 VREvent_Scroll_t_0915; +#pragma pack( push, 4 ) +struct VREvent_Scroll_t_0915 +{ + float xdelta; + float ydelta; + uint32_t repeatCount; +}; +#pragma pack( pop ) + +typedef struct VREvent_SeatedZeroPoseReset_t VREvent_SeatedZeroPoseReset_t; +#pragma pack( push, 1 ) +struct VREvent_SeatedZeroPoseReset_t +{ + bool bResetBySystemMenu; +}; +#pragma pack( pop ) + +typedef struct VREvent_ShowDevTools_t VREvent_ShowDevTools_t; +#pragma pack( push, 4 ) +struct VREvent_ShowDevTools_t +{ + int32_t nBrowserIdentifier; +}; +#pragma pack( pop ) + +typedef struct VREvent_ShowUI_t VREvent_ShowUI_t; +#pragma pack( push, 4 ) +struct VREvent_ShowUI_t +{ + uint32_t eType; +}; +#pragma pack( pop ) + +typedef struct VREvent_SpatialAnchor_t VREvent_SpatialAnchor_t; +#pragma pack( push, 4 ) +struct VREvent_SpatialAnchor_t +{ + uint32_t unHandle; +}; +#pragma pack( pop ) + +typedef struct VREvent_Status_t VREvent_Status_t; +#pragma pack( push, 4 ) +struct VREvent_Status_t +{ + uint32_t statusState; +}; +#pragma pack( pop ) + +typedef struct VREvent_TouchPadMove_t VREvent_TouchPadMove_t; +#pragma pack( push, 4 ) +struct VREvent_TouchPadMove_t +{ + bool bFingerDown; + uint8_t __pad_1[3]; + float flSecondsFingerDown; + float fValueXFirst; + float fValueYFirst; + float fValueXRaw; + float fValueYRaw; +}; +#pragma pack( pop ) + +typedef struct VREvent_WebConsole_t VREvent_WebConsole_t; +#pragma pack( push, 8 ) +struct VREvent_WebConsole_t +{ + uint64_t webConsoleHandle; +}; +#pragma pack( pop ) + +typedef struct TrackedDevicePose_t TrackedDevicePose_t; +#pragma pack( push, 4 ) +struct TrackedDevicePose_t +{ + HmdMatrix34_t mDeviceToAbsoluteTracking; + HmdVector3_t vVelocity; + HmdVector3_t vAngularVelocity; + uint32_t eTrackingResult; + bool bPoseIsValid; + bool bDeviceIsConnected; + uint8_t __pad_78[2]; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1168 VREvent_Data_t_1168; +#pragma pack( push, 8 ) +union VREvent_Data_t_1168 +{ + VREvent_Reserved_t_113b reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_1322 scroll; + VREvent_Process_t_1210 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1168 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; + VREvent_ProgressUpdate_t progressUpdate; + VREvent_ShowUI_t showUi; + VREvent_ShowDevTools_t showDevTools; + VREvent_HDCPError_t hdcpError; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_11030 VREvent_Data_t_11030; +#pragma pack( push, 8 ) +union VREvent_Data_t_11030 +{ + VREvent_Reserved_t_113b reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_1322 scroll; + VREvent_Process_t_1210 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; + VREvent_ProgressUpdate_t progressUpdate; + VREvent_ShowUI_t showUi; + VREvent_ShowDevTools_t showDevTools; + VREvent_HDCPError_t hdcpError; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1322 VREvent_Data_t_1322; +#pragma pack( push, 8 ) +union VREvent_Data_t_1322 +{ + VREvent_Reserved_t_113b reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_1322 scroll; + VREvent_Process_t_1210 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; + VREvent_ProgressUpdate_t progressUpdate; + VREvent_ShowUI_t showUi; + VREvent_ShowDevTools_t showDevTools; + VREvent_HDCPError_t hdcpError; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1210 VREvent_Data_t_1210; +#pragma pack( push, 8 ) +union VREvent_Data_t_1210 +{ + VREvent_Reserved_t_113b reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_1210 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; + VREvent_ProgressUpdate_t progressUpdate; + VREvent_ShowUI_t showUi; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_113b VREvent_Data_t_113b; +#pragma pack( push, 8 ) +union VREvent_Data_t_113b +{ + VREvent_Reserved_t_113b reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; + VREvent_ProgressUpdate_t progressUpdate; + VREvent_ShowUI_t showUi; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1016 VREvent_Data_t_1016; +#pragma pack( push, 8 ) +union VREvent_Data_t_1016 +{ + VREvent_Reserved_t_1013 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1016 inputBinding; + VREvent_InputActionManifestLoad_t actionManifest; + VREvent_SpatialAnchor_t spatialAnchor; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1015 VREvent_Data_t_1015; +#pragma pack( push, 8 ) +union VREvent_Data_t_1015 +{ + VREvent_Reserved_t_1013 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; + VREvent_InputBindingLoad_t_1015 inputBinding; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1014 VREvent_Data_t_1014; +#pragma pack( push, 8 ) +union VREvent_Data_t_1014 +{ + VREvent_Reserved_t_1013 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_1014 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; + VREvent_WebConsole_t webConsole; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1013 VREvent_Data_t_1013; +#pragma pack( push, 8 ) +union VREvent_Data_t_1013 +{ + VREvent_Reserved_t_1013 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1012 VREvent_Data_t_1012; +#pragma pack( push, 8 ) +union VREvent_Data_t_1012 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; + VREvent_HapticVibration_t hapticVibration; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_1011 VREvent_Data_t_1011; +#pragma pack( push, 8 ) +union VREvent_Data_t_1011 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; + VREvent_DualAnalog_t dualAnalog; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_106 VREvent_Data_t_106; +#pragma pack( push, 8 ) +union VREvent_Data_t_106 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; + VREvent_Property_t property; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_105 VREvent_Data_t_105; +#pragma pack( push, 8 ) +union VREvent_Data_t_105 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_103 VREvent_Data_t_103; +#pragma pack( push, 8 ) +union VREvent_Data_t_103 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; + VREvent_EditingCameraSurface_t cameraSurface; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_102 VREvent_Data_t_102; +#pragma pack( push, 8 ) +union VREvent_Data_t_102 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; + VREvent_ScreenshotProgress_t screenshotProgress; + VREvent_ApplicationLaunch_t applicationLaunch; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_101 VREvent_Data_t_101; +#pragma pack( push, 8 ) +union VREvent_Data_t_101 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + VREvent_Screenshot_t screenshot; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_0918 VREvent_Data_t_0918; +#pragma pack( push, 8 ) +union VREvent_Data_t_0918 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_0915 VREvent_Data_t_0915; +#pragma pack( push, 8 ) +union VREvent_Data_t_0915 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Scroll_t_0915 scroll; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; + VREvent_TouchPadMove_t touchPadMove; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_0914 VREvent_Data_t_0914; +#pragma pack( push, 8 ) +union VREvent_Data_t_0914 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; + VREvent_PerformanceTest_t performanceTest; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_0912 VREvent_Data_t_0912; +#pragma pack( push, 8 ) +union VREvent_Data_t_0912 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_0912 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0912 keyboard; + VREvent_Ipd_t ipd; + VREvent_Chaperone_t chaperone; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_0910 VREvent_Data_t_0910; +#pragma pack( push, 8 ) +union VREvent_Data_t_0910 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_090 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; + VREvent_Keyboard_t_0910 keyboard; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_097 VREvent_Data_t_097; +#pragma pack( push, 8 ) +union VREvent_Data_t_097 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_090 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; + VREvent_Status_t status; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_093 VREvent_Data_t_093; +#pragma pack( push, 8 ) +union VREvent_Data_t_093 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_090 process; + VREvent_Notification_t_093 notification; + VREvent_Overlay_t_092 overlay; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_092 VREvent_Data_t_092; +#pragma pack( push, 8 ) +union VREvent_Data_t_092 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_090 process; + VREvent_Notification_t_092 notification; + VREvent_Overlay_t_092 overlay; +}; +#pragma pack( pop ) + +typedef union VREvent_Data_t_090 VREvent_Data_t_090; +#pragma pack( push, 8 ) +union VREvent_Data_t_090 +{ + VREvent_Reserved_t_090 reserved; + VREvent_Controller_t controller; + VREvent_Mouse_t mouse; + VREvent_Process_t_090 process; +}; +#pragma pack( pop ) + +typedef union VROverlayIntersectionMaskPrimitive_Data_t VROverlayIntersectionMaskPrimitive_Data_t; +#pragma pack( push, 4 ) +union VROverlayIntersectionMaskPrimitive_Data_t +{ + IntersectionMaskRectangle_t m_Rectangle; + IntersectionMaskCircle_t m_Circle; +}; +#pragma pack( pop ) + +typedef struct VRTextureBounds_t VRTextureBounds_t; +#pragma pack( push, 4 ) +struct VRTextureBounds_t +{ + float uMin; + float vMin; + float uMax; + float vMax; +}; +#pragma pack( pop ) + +typedef struct ChaperoneSeatedBoundsInfo_t ChaperoneSeatedBoundsInfo_t; +#pragma pack( push, 4 ) +struct ChaperoneSeatedBoundsInfo_t +{ + HmdVector3_t vSeatedHeadPosition; + HmdVector3_t (vDeskEdgePositions)[2]; +}; +#pragma pack( pop ) + +typedef struct ChaperoneSoftBoundsInfo_t ChaperoneSoftBoundsInfo_t; +#pragma pack( push, 4 ) +struct ChaperoneSoftBoundsInfo_t +{ + HmdQuad_t quadCorners; +}; +#pragma pack( pop ) + +typedef struct Compositor_BenchmarkResults Compositor_BenchmarkResults; +#pragma pack( push, 4 ) +struct Compositor_BenchmarkResults +{ + float m_flMegaPixelsPerSecond; + float m_flHmdRecommendedMegaPixelsPerSecond; +}; +#pragma pack( pop ) + +typedef struct Compositor_CumulativeStats_1267 Compositor_CumulativeStats_1267; +#pragma pack( push, 8 ) +struct Compositor_CumulativeStats_1267 +{ + uint32_t m_nPid; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nNumReprojectedFrames; + uint32_t m_nNumFramePresentsOnStartup; + uint32_t m_nNumDroppedFramesOnStartup; + uint32_t m_nNumReprojectedFramesOnStartup; + uint32_t m_nNumLoading; + uint32_t m_nNumFramePresentsLoading; + uint32_t m_nNumDroppedFramesLoading; + uint32_t m_nNumReprojectedFramesLoading; + uint32_t m_nNumTimedOut; + uint32_t m_nNumFramePresentsTimedOut; + uint32_t m_nNumDroppedFramesTimedOut; + uint32_t m_nNumReprojectedFramesTimedOut; + uint32_t m_nNumFrameSubmits; + double m_flSumCompositorCPUTimeMS; + double m_flSumCompositorGPUTimeMS; + double m_flSumTargetFrameTimes; + double m_flSumApplicationCPUTimeMS; + double m_flSumApplicationGPUTimeMS; + uint32_t m_nNumFramesWithDepth; + uint8_t __pad_108[4]; +}; +#pragma pack( pop ) + +typedef struct Compositor_CumulativeStats_100 Compositor_CumulativeStats_100; +#pragma pack( push, 4 ) +struct Compositor_CumulativeStats_100 +{ + uint32_t m_nPid; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nNumReprojectedFrames; + uint32_t m_nNumFramePresentsOnStartup; + uint32_t m_nNumDroppedFramesOnStartup; + uint32_t m_nNumReprojectedFramesOnStartup; + uint32_t m_nNumLoading; + uint32_t m_nNumFramePresentsLoading; + uint32_t m_nNumDroppedFramesLoading; + uint32_t m_nNumReprojectedFramesLoading; + uint32_t m_nNumTimedOut; + uint32_t m_nNumFramePresentsTimedOut; + uint32_t m_nNumDroppedFramesTimedOut; + uint32_t m_nNumReprojectedFramesTimedOut; +}; +#pragma pack( pop ) + +typedef struct Compositor_OverlaySettings Compositor_OverlaySettings; +#pragma pack( push, 4 ) +struct Compositor_OverlaySettings +{ + uint32_t size; + bool curved; + bool antialias; + uint8_t __pad_6[2]; + float scale; + float distance; + float alpha; + float uOffset; + float vOffset; + float uScale; + float vScale; + float gridDivs; + float gridWidth; + float gridScale; + HmdMatrix44_t transform; +}; +#pragma pack( pop ) + +typedef struct Compositor_StageRenderSettings Compositor_StageRenderSettings; +#pragma pack( push, 4 ) +struct Compositor_StageRenderSettings +{ + HmdColor_t m_PrimaryColor; + HmdColor_t m_SecondaryColor; + float m_flVignetteInnerRadius; + float m_flVignetteOuterRadius; + float m_flFresnelStrength; + bool m_bBackfaceCulling; + bool m_bGreyscale; + bool m_bWireframe; + uint8_t __pad_47[1]; +}; +#pragma pack( pop ) + +typedef struct Compositor_TextureBounds Compositor_TextureBounds; +#pragma pack( push, 4 ) +struct Compositor_TextureBounds +{ + float uMin; + float vMin; + float uMax; + float vMax; +}; +#pragma pack( pop ) + +typedef struct DistortionCoordinates_t DistortionCoordinates_t; +#pragma pack( push, 4 ) +struct DistortionCoordinates_t +{ + float (rfRed)[2]; + float (rfGreen)[2]; + float (rfBlue)[2]; +}; +#pragma pack( pop ) + +typedef struct DriverDirectMode_FrameTiming DriverDirectMode_FrameTiming; +#pragma pack( push, 4 ) +struct DriverDirectMode_FrameTiming +{ + uint32_t m_nSize; + uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; +}; +#pragma pack( pop ) + +typedef struct HmdRect2_t HmdRect2_t; +#pragma pack( push, 4 ) +struct HmdRect2_t +{ + HmdVector2_t vTopLeft; + HmdVector2_t vBottomRight; +}; +#pragma pack( pop ) + +typedef struct ImuSample_t ImuSample_t; +#pragma pack( push, 8 ) +struct ImuSample_t +{ + double fSampleTime; + HmdVector3d_t vAccel; + HmdVector3d_t vGyro; + uint32_t unOffScaleFlags; + uint8_t __pad_60[4]; +}; +#pragma pack( pop ) + +typedef struct InputBindingInfo_t_11030 InputBindingInfo_t_11030; +#pragma pack( push, 1 ) +struct InputBindingInfo_t_11030 +{ + char (rchDevicePathName)[128]; + char (rchInputPathName)[128]; + char (rchModeName)[128]; + char (rchSlotName)[128]; + char (rchInputSourceType)[32]; +}; +#pragma pack( pop ) + +typedef struct InputBindingInfo_t_1517 InputBindingInfo_t_1517; +#pragma pack( push, 1 ) +struct InputBindingInfo_t_1517 +{ + char (rchDevicePathName)[128]; + char (rchInputPathName)[128]; + char (rchModeName)[128]; + char (rchSlotName)[128]; +}; +#pragma pack( pop ) + +typedef struct NotificationItem NotificationItem; +#pragma pack( push, 4 ) +struct NotificationItem +{ + uint32_t notificationId; +}; +#pragma pack( pop ) + +typedef struct RenderModel_ComponentState_t RenderModel_ComponentState_t; +#pragma pack( push, 4 ) +struct RenderModel_ComponentState_t +{ + HmdMatrix34_t mTrackingToComponentRenderModel; + HmdMatrix34_t mTrackingToComponentLocal; + uint32_t uProperties; +}; +#pragma pack( pop ) + +typedef struct RenderModel_ControllerMode_State_t RenderModel_ControllerMode_State_t; +#pragma pack( push, 1 ) +struct RenderModel_ControllerMode_State_t +{ + bool bScrollWheelVisible; +}; +#pragma pack( pop ) + +typedef struct RenderModel_Vertex_t RenderModel_Vertex_t; +#pragma pack( push, 4 ) +struct RenderModel_Vertex_t +{ + HmdVector3_t vPosition; + HmdVector3_t vNormal; + float (rfTextureCoord)[2]; +}; +#pragma pack( pop ) + +typedef struct SpatialAnchorPose_t SpatialAnchorPose_t; +#pragma pack( push, 4 ) +struct SpatialAnchorPose_t +{ + HmdMatrix34_t mAnchorToAbsoluteTracking; +}; +#pragma pack( pop ) + +typedef struct VRActiveActionSet_t_1016 VRActiveActionSet_t_1016; +#pragma pack( push, 8 ) +struct VRActiveActionSet_t_1016 +{ + uint64_t ulActionSet; + uint64_t ulRestrictedToDevice; + uint64_t ulSecondaryActionSet; + uint32_t unPadding; + int32_t nPriority; +}; +#pragma pack( pop ) + +typedef struct VRActiveActionSet_t_1015 VRActiveActionSet_t_1015; +#pragma pack( push, 8 ) +struct VRActiveActionSet_t_1015 +{ + uint64_t ulActionSet; + uint64_t ulRestrictedToDevice; + uint64_t ulSecondaryActionSet; +}; +#pragma pack( pop ) + +typedef struct VRBoneTransform_t VRBoneTransform_t; +#pragma pack( push, 4 ) +struct VRBoneTransform_t +{ + HmdVector4_t position; + HmdQuaternionf_t orientation; +}; +#pragma pack( pop ) + +typedef struct VRControllerAxis_t VRControllerAxis_t; +#pragma pack( push, 4 ) +struct VRControllerAxis_t +{ + float x; + float y; +}; +#pragma pack( pop ) + +typedef struct VROverlayIntersectionMaskPrimitive_t VROverlayIntersectionMaskPrimitive_t; +#pragma pack( push, 4 ) +struct VROverlayIntersectionMaskPrimitive_t +{ + uint32_t m_nPrimitiveType; + VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; +}; +#pragma pack( pop ) + +typedef struct VROverlayIntersectionParams_t VROverlayIntersectionParams_t; +#pragma pack( push, 4 ) +struct VROverlayIntersectionParams_t +{ + HmdVector3_t vSource; + HmdVector3_t vDirection; + uint32_t eOrigin; +}; +#pragma pack( pop ) + +typedef struct VROverlayIntersectionResults_t VROverlayIntersectionResults_t; +#pragma pack( push, 4 ) +struct VROverlayIntersectionResults_t +{ + HmdVector3_t vPoint; + HmdVector3_t vNormal; + HmdVector2_t vUVs; + float fDistance; +}; +#pragma pack( pop ) + +typedef struct VROverlayProjection_t VROverlayProjection_t; +#pragma pack( push, 4 ) +struct VROverlayProjection_t +{ + float fLeft; + float fRight; + float fTop; + float fBottom; +}; +#pragma pack( pop ) + +typedef struct VRSkeletalSummaryData_t VRSkeletalSummaryData_t; +#pragma pack( push, 4 ) +struct VRSkeletalSummaryData_t +{ + float (flFingerCurl)[5]; + float (flFingerSplay)[4]; +}; +#pragma pack( pop ) + +typedef struct u64_RenderModel_TextureMap_t_1237 u64_RenderModel_TextureMap_t_1237; +typedef struct w64_RenderModel_TextureMap_t_1237 w64_RenderModel_TextureMap_t_1237; +typedef struct w32_RenderModel_TextureMap_t_1237 u32_RenderModel_TextureMap_t_1237; +typedef struct w32_RenderModel_TextureMap_t_1237 w32_RenderModel_TextureMap_t_1237; +typedef struct u64_RenderModel_TextureMap_t_11111 u64_RenderModel_TextureMap_t_11111; +typedef struct w64_RenderModel_TextureMap_t_11111 w64_RenderModel_TextureMap_t_11111; +typedef struct w32_RenderModel_TextureMap_t_11111 u32_RenderModel_TextureMap_t_11111; +typedef struct w32_RenderModel_TextureMap_t_11111 w32_RenderModel_TextureMap_t_11111; +typedef struct u64_RenderModel_TextureMap_t_090 u64_RenderModel_TextureMap_t_090; +typedef struct w64_RenderModel_TextureMap_t_090 w64_RenderModel_TextureMap_t_090; +typedef struct w32_RenderModel_TextureMap_t_090 u32_RenderModel_TextureMap_t_090; +typedef struct w32_RenderModel_TextureMap_t_090 w32_RenderModel_TextureMap_t_090; +typedef struct w64_Texture_t u64_Texture_t; +typedef struct w64_Texture_t w64_Texture_t; +typedef struct w32_Texture_t u32_Texture_t; +typedef struct w32_Texture_t w32_Texture_t; +typedef struct w64_VRTextureDepthInfo_t u64_VRTextureDepthInfo_t; +typedef struct w64_VRTextureDepthInfo_t w64_VRTextureDepthInfo_t; +typedef struct w32_VRTextureDepthInfo_t u32_VRTextureDepthInfo_t; +typedef struct w32_VRTextureDepthInfo_t w32_VRTextureDepthInfo_t; +typedef struct w64_AppOverrideKeys_t u64_AppOverrideKeys_t; +typedef struct w64_AppOverrideKeys_t w64_AppOverrideKeys_t; +typedef struct w32_AppOverrideKeys_t u32_AppOverrideKeys_t; +typedef struct w32_AppOverrideKeys_t w32_AppOverrideKeys_t; +typedef struct w64_COpenVRContext_11030 u64_COpenVRContext_11030; +typedef struct w64_COpenVRContext_11030 w64_COpenVRContext_11030; +typedef struct w32_COpenVRContext_11030 u32_COpenVRContext_11030; +typedef struct w32_COpenVRContext_11030 w32_COpenVRContext_11030; +typedef struct w64_COpenVRContext_1517 u64_COpenVRContext_1517; +typedef struct w64_COpenVRContext_1517 w64_COpenVRContext_1517; +typedef struct w32_COpenVRContext_1517 u32_COpenVRContext_1517; +typedef struct w32_COpenVRContext_1517 w32_COpenVRContext_1517; +typedef struct w64_COpenVRContext_1210 u64_COpenVRContext_1210; +typedef struct w64_COpenVRContext_1210 w64_COpenVRContext_1210; +typedef struct w32_COpenVRContext_1210 u32_COpenVRContext_1210; +typedef struct w32_COpenVRContext_1210 w32_COpenVRContext_1210; +typedef struct w64_COpenVRContext_1016 u64_COpenVRContext_1016; +typedef struct w64_COpenVRContext_1016 w64_COpenVRContext_1016; +typedef struct w32_COpenVRContext_1016 u32_COpenVRContext_1016; +typedef struct w32_COpenVRContext_1016 w32_COpenVRContext_1016; +typedef struct w64_COpenVRContext_1015 u64_COpenVRContext_1015; +typedef struct w64_COpenVRContext_1015 w64_COpenVRContext_1015; +typedef struct w32_COpenVRContext_1015 u32_COpenVRContext_1015; +typedef struct w32_COpenVRContext_1015 w32_COpenVRContext_1015; +typedef struct w64_COpenVRContext_108 u64_COpenVRContext_108; +typedef struct w64_COpenVRContext_108 w64_COpenVRContext_108; +typedef struct w32_COpenVRContext_108 u32_COpenVRContext_108; +typedef struct w32_COpenVRContext_108 w32_COpenVRContext_108; +typedef struct w64_COpenVRContext_102 u64_COpenVRContext_102; +typedef struct w64_COpenVRContext_102 w64_COpenVRContext_102; +typedef struct w32_COpenVRContext_102 u32_COpenVRContext_102; +typedef struct w32_COpenVRContext_102 w32_COpenVRContext_102; +typedef struct w64_COpenVRContext_101 u64_COpenVRContext_101; +typedef struct w64_COpenVRContext_101 w64_COpenVRContext_101; +typedef struct w32_COpenVRContext_101 u32_COpenVRContext_101; +typedef struct w32_COpenVRContext_101 w32_COpenVRContext_101; +typedef struct w64_COpenVRContext_100 u64_COpenVRContext_100; +typedef struct w64_COpenVRContext_100 w64_COpenVRContext_100; +typedef struct w32_COpenVRContext_100 u32_COpenVRContext_100; +typedef struct w32_COpenVRContext_100 w32_COpenVRContext_100; +typedef struct w64_COpenVRContext_0917 u64_COpenVRContext_0917; +typedef struct w64_COpenVRContext_0917 w64_COpenVRContext_0917; +typedef struct w32_COpenVRContext_0917 u32_COpenVRContext_0917; +typedef struct w32_COpenVRContext_0917 w32_COpenVRContext_0917; +typedef struct w64_CameraVideoStreamFrameHeader_t_1017 u64_CameraVideoStreamFrameHeader_t_1017; +typedef struct w64_CameraVideoStreamFrameHeader_t_1017 w64_CameraVideoStreamFrameHeader_t_1017; +typedef struct u32_CameraVideoStreamFrameHeader_t_1017 u32_CameraVideoStreamFrameHeader_t_1017; +typedef struct w32_CameraVideoStreamFrameHeader_t_1017 w32_CameraVideoStreamFrameHeader_t_1017; +typedef struct w64_CameraVideoStreamFrameHeader_t_100 u64_CameraVideoStreamFrameHeader_t_100; +typedef struct w64_CameraVideoStreamFrameHeader_t_100 w64_CameraVideoStreamFrameHeader_t_100; +typedef struct w32_CameraVideoStreamFrameHeader_t_100 u32_CameraVideoStreamFrameHeader_t_100; +typedef struct w32_CameraVideoStreamFrameHeader_t_100 w32_CameraVideoStreamFrameHeader_t_100; +typedef struct u64_CameraVideoStreamFrame_t_0914 u64_CameraVideoStreamFrame_t_0914; +typedef struct w64_CameraVideoStreamFrame_t_0914 w64_CameraVideoStreamFrame_t_0914; +typedef struct u32_CameraVideoStreamFrame_t_0914 u32_CameraVideoStreamFrame_t_0914; +typedef struct w32_CameraVideoStreamFrame_t_0914 w32_CameraVideoStreamFrame_t_0914; +typedef struct u64_CameraVideoStreamFrame_t_0912 u64_CameraVideoStreamFrame_t_0912; +typedef struct w64_CameraVideoStreamFrame_t_0912 w64_CameraVideoStreamFrame_t_0912; +typedef struct w32_CameraVideoStreamFrame_t_0912 u32_CameraVideoStreamFrame_t_0912; +typedef struct w32_CameraVideoStreamFrame_t_0912 w32_CameraVideoStreamFrame_t_0912; +typedef struct w64_Compositor_FrameTiming_1017 u64_Compositor_FrameTiming_1017; +typedef struct w64_Compositor_FrameTiming_1017 w64_Compositor_FrameTiming_1017; +typedef struct w32_Compositor_FrameTiming_1017 u32_Compositor_FrameTiming_1017; +typedef struct w32_Compositor_FrameTiming_1017 w32_Compositor_FrameTiming_1017; +typedef struct w64_Compositor_FrameTiming_103a u64_Compositor_FrameTiming_103a; +typedef struct w64_Compositor_FrameTiming_103a w64_Compositor_FrameTiming_103a; +typedef struct w32_Compositor_FrameTiming_103a u32_Compositor_FrameTiming_103a; +typedef struct w32_Compositor_FrameTiming_103a w32_Compositor_FrameTiming_103a; +typedef struct u64_Compositor_FrameTiming_102 u64_Compositor_FrameTiming_102; +typedef struct w64_Compositor_FrameTiming_102 w64_Compositor_FrameTiming_102; +typedef struct u32_Compositor_FrameTiming_102 u32_Compositor_FrameTiming_102; +typedef struct w32_Compositor_FrameTiming_102 w32_Compositor_FrameTiming_102; +typedef struct w64_Compositor_FrameTiming_0920 u64_Compositor_FrameTiming_0920; +typedef struct w64_Compositor_FrameTiming_0920 w64_Compositor_FrameTiming_0920; +typedef struct w32_Compositor_FrameTiming_0920 u32_Compositor_FrameTiming_0920; +typedef struct w32_Compositor_FrameTiming_0920 w32_Compositor_FrameTiming_0920; +typedef struct w64_Compositor_FrameTiming_0915 u64_Compositor_FrameTiming_0915; +typedef struct w64_Compositor_FrameTiming_0915 w64_Compositor_FrameTiming_0915; +typedef struct w32_Compositor_FrameTiming_0915 u32_Compositor_FrameTiming_0915; +typedef struct w32_Compositor_FrameTiming_0915 w32_Compositor_FrameTiming_0915; +typedef struct u64_Compositor_FrameTiming_0914 u64_Compositor_FrameTiming_0914; +typedef struct w64_Compositor_FrameTiming_0914 w64_Compositor_FrameTiming_0914; +typedef struct u32_Compositor_FrameTiming_0914 u32_Compositor_FrameTiming_0914; +typedef struct w32_Compositor_FrameTiming_0914 w32_Compositor_FrameTiming_0914; +typedef struct u64_Compositor_FrameTiming_0913 u64_Compositor_FrameTiming_0913; +typedef struct w64_Compositor_FrameTiming_0913 w64_Compositor_FrameTiming_0913; +typedef struct u32_Compositor_FrameTiming_0913 u32_Compositor_FrameTiming_0913; +typedef struct w32_Compositor_FrameTiming_0913 w32_Compositor_FrameTiming_0913; +typedef struct u64_Compositor_FrameTiming_0912 u64_Compositor_FrameTiming_0912; +typedef struct w64_Compositor_FrameTiming_0912 w64_Compositor_FrameTiming_0912; +typedef struct u32_Compositor_FrameTiming_0912 u32_Compositor_FrameTiming_0912; +typedef struct w32_Compositor_FrameTiming_0912 w32_Compositor_FrameTiming_0912; +typedef struct u64_Compositor_FrameTiming_093 u64_Compositor_FrameTiming_093; +typedef struct w64_Compositor_FrameTiming_093 w64_Compositor_FrameTiming_093; +typedef struct u32_Compositor_FrameTiming_093 u32_Compositor_FrameTiming_093; +typedef struct w32_Compositor_FrameTiming_093 w32_Compositor_FrameTiming_093; +typedef struct u64_Compositor_FrameTiming_090 u64_Compositor_FrameTiming_090; +typedef struct w64_Compositor_FrameTiming_090 w64_Compositor_FrameTiming_090; +typedef struct u32_Compositor_FrameTiming_090 u32_Compositor_FrameTiming_090; +typedef struct w32_Compositor_FrameTiming_090 w32_Compositor_FrameTiming_090; +typedef struct w64_D3D12TextureData_t u64_D3D12TextureData_t; +typedef struct w64_D3D12TextureData_t w64_D3D12TextureData_t; +typedef struct w32_D3D12TextureData_t u32_D3D12TextureData_t; +typedef struct w32_D3D12TextureData_t w32_D3D12TextureData_t; +typedef struct w64_HiddenAreaMesh_t u64_HiddenAreaMesh_t; +typedef struct w64_HiddenAreaMesh_t w64_HiddenAreaMesh_t; +typedef struct w32_HiddenAreaMesh_t u32_HiddenAreaMesh_t; +typedef struct w32_HiddenAreaMesh_t w32_HiddenAreaMesh_t; +typedef struct u_IVRDebug u_IVRDebug; +typedef struct u_IVRDebug u64_IVRDebug; +typedef struct u_IVRDebug u32_IVRDebug; +typedef struct w_IVRDebug w_IVRDebug; +typedef struct w_IVRDebug w64_IVRDebug; +typedef struct w_IVRDebug w32_IVRDebug; +typedef struct u_IVRSpatialAnchors u_IVRSpatialAnchors; +typedef struct u_IVRSpatialAnchors u64_IVRSpatialAnchors; +typedef struct u_IVRSpatialAnchors u32_IVRSpatialAnchors; +typedef struct w_IVRSpatialAnchors w_IVRSpatialAnchors; +typedef struct w_IVRSpatialAnchors w64_IVRSpatialAnchors; +typedef struct w_IVRSpatialAnchors w32_IVRSpatialAnchors; +typedef struct w64_InputAnalogActionData_t u64_InputAnalogActionData_t; +typedef struct w64_InputAnalogActionData_t w64_InputAnalogActionData_t; +typedef struct u32_InputAnalogActionData_t u32_InputAnalogActionData_t; +typedef struct w32_InputAnalogActionData_t w32_InputAnalogActionData_t; +typedef struct w64_InputDigitalActionData_t u64_InputDigitalActionData_t; +typedef struct w64_InputDigitalActionData_t w64_InputDigitalActionData_t; +typedef struct u32_InputDigitalActionData_t u32_InputDigitalActionData_t; +typedef struct w32_InputDigitalActionData_t w32_InputDigitalActionData_t; +typedef struct w64_InputOriginInfo_t u64_InputOriginInfo_t; +typedef struct w64_InputOriginInfo_t w64_InputOriginInfo_t; +typedef struct u32_InputOriginInfo_t u32_InputOriginInfo_t; +typedef struct w32_InputOriginInfo_t w32_InputOriginInfo_t; +typedef struct w64_InputPoseActionData_t u64_InputPoseActionData_t; +typedef struct w64_InputPoseActionData_t w64_InputPoseActionData_t; +typedef struct u32_InputPoseActionData_t u32_InputPoseActionData_t; +typedef struct w32_InputPoseActionData_t w32_InputPoseActionData_t; +typedef struct w64_InputSkeletalActionData_t_113b u64_InputSkeletalActionData_t_113b; +typedef struct w64_InputSkeletalActionData_t_113b w64_InputSkeletalActionData_t_113b; +typedef struct u32_InputSkeletalActionData_t_113b u32_InputSkeletalActionData_t_113b; +typedef struct w32_InputSkeletalActionData_t_113b w32_InputSkeletalActionData_t_113b; +typedef struct w64_InputSkeletalActionData_t_1016 u64_InputSkeletalActionData_t_1016; +typedef struct w64_InputSkeletalActionData_t_1016 w64_InputSkeletalActionData_t_1016; +typedef struct u32_InputSkeletalActionData_t_1016 u32_InputSkeletalActionData_t_1016; +typedef struct w32_InputSkeletalActionData_t_1016 w32_InputSkeletalActionData_t_1016; +typedef struct w64_InputSkeletonActionData_t u64_InputSkeletonActionData_t; +typedef struct w64_InputSkeletonActionData_t w64_InputSkeletonActionData_t; +typedef struct u32_InputSkeletonActionData_t u32_InputSkeletonActionData_t; +typedef struct w32_InputSkeletonActionData_t w32_InputSkeletonActionData_t; +typedef struct w64_NotificationBitmap u64_NotificationBitmap; +typedef struct w64_NotificationBitmap w64_NotificationBitmap; +typedef struct w32_NotificationBitmap u32_NotificationBitmap; +typedef struct w32_NotificationBitmap w32_NotificationBitmap; +typedef struct w64_NotificationBitmap_t u64_NotificationBitmap_t; +typedef struct w64_NotificationBitmap_t w64_NotificationBitmap_t; +typedef struct w32_NotificationBitmap_t u32_NotificationBitmap_t; +typedef struct w32_NotificationBitmap_t w32_NotificationBitmap_t; +typedef struct u64_RenderModel_t_0912 u64_RenderModel_t_0912; +typedef struct w64_RenderModel_t_0912 w64_RenderModel_t_0912; +typedef struct w32_RenderModel_t_0912 u32_RenderModel_t_0912; +typedef struct w32_RenderModel_t_0912 w32_RenderModel_t_0912; +typedef struct u64_RenderModel_t_090 u64_RenderModel_t_090; +typedef struct w64_RenderModel_t_090 w64_RenderModel_t_090; +typedef struct w32_RenderModel_t_090 u32_RenderModel_t_090; +typedef struct w32_RenderModel_t_090 w32_RenderModel_t_090; +typedef struct u64_VRControllerState001_t u64_VRControllerState001_t; +typedef struct w64_VRControllerState001_t w64_VRControllerState001_t; +typedef struct u32_VRControllerState001_t u32_VRControllerState001_t; +typedef struct w32_VRControllerState001_t w32_VRControllerState001_t; +typedef struct u64_VREvent_t_1168 u64_VREvent_t_1168; +typedef struct w64_VREvent_t_1168 w64_VREvent_t_1168; +typedef struct u32_VREvent_t_1168 u32_VREvent_t_1168; +typedef struct w32_VREvent_t_1168 w32_VREvent_t_1168; +typedef struct u64_VREvent_t_11030 u64_VREvent_t_11030; +typedef struct w64_VREvent_t_11030 w64_VREvent_t_11030; +typedef struct u32_VREvent_t_11030 u32_VREvent_t_11030; +typedef struct w32_VREvent_t_11030 w32_VREvent_t_11030; +typedef struct u64_VREvent_t_1322 u64_VREvent_t_1322; +typedef struct w64_VREvent_t_1322 w64_VREvent_t_1322; +typedef struct u32_VREvent_t_1322 u32_VREvent_t_1322; +typedef struct w32_VREvent_t_1322 w32_VREvent_t_1322; +typedef struct u64_VREvent_t_1210 u64_VREvent_t_1210; +typedef struct w64_VREvent_t_1210 w64_VREvent_t_1210; +typedef struct u32_VREvent_t_1210 u32_VREvent_t_1210; +typedef struct w32_VREvent_t_1210 w32_VREvent_t_1210; +typedef struct u64_VREvent_t_113b u64_VREvent_t_113b; +typedef struct w64_VREvent_t_113b w64_VREvent_t_113b; +typedef struct u32_VREvent_t_113b u32_VREvent_t_113b; +typedef struct w32_VREvent_t_113b w32_VREvent_t_113b; +typedef struct u64_VREvent_t_1016 u64_VREvent_t_1016; +typedef struct w64_VREvent_t_1016 w64_VREvent_t_1016; +typedef struct u32_VREvent_t_1016 u32_VREvent_t_1016; +typedef struct w32_VREvent_t_1016 w32_VREvent_t_1016; +typedef struct u64_VREvent_t_1015 u64_VREvent_t_1015; +typedef struct w64_VREvent_t_1015 w64_VREvent_t_1015; +typedef struct u32_VREvent_t_1015 u32_VREvent_t_1015; +typedef struct w32_VREvent_t_1015 w32_VREvent_t_1015; +typedef struct u64_VREvent_t_1014 u64_VREvent_t_1014; +typedef struct w64_VREvent_t_1014 w64_VREvent_t_1014; +typedef struct u32_VREvent_t_1014 u32_VREvent_t_1014; +typedef struct w32_VREvent_t_1014 w32_VREvent_t_1014; +typedef struct u64_VREvent_t_1013 u64_VREvent_t_1013; +typedef struct w64_VREvent_t_1013 w64_VREvent_t_1013; +typedef struct u32_VREvent_t_1013 u32_VREvent_t_1013; +typedef struct w32_VREvent_t_1013 w32_VREvent_t_1013; +typedef struct u64_VREvent_t_1012 u64_VREvent_t_1012; +typedef struct w64_VREvent_t_1012 w64_VREvent_t_1012; +typedef struct u32_VREvent_t_1012 u32_VREvent_t_1012; +typedef struct w32_VREvent_t_1012 w32_VREvent_t_1012; +typedef struct u64_VREvent_t_1011 u64_VREvent_t_1011; +typedef struct w64_VREvent_t_1011 w64_VREvent_t_1011; +typedef struct u32_VREvent_t_1011 u32_VREvent_t_1011; +typedef struct w32_VREvent_t_1011 w32_VREvent_t_1011; +typedef struct u64_VREvent_t_106 u64_VREvent_t_106; +typedef struct w64_VREvent_t_106 w64_VREvent_t_106; +typedef struct u32_VREvent_t_106 u32_VREvent_t_106; +typedef struct w32_VREvent_t_106 w32_VREvent_t_106; +typedef struct u64_VREvent_t_105 u64_VREvent_t_105; +typedef struct w64_VREvent_t_105 w64_VREvent_t_105; +typedef struct u32_VREvent_t_105 u32_VREvent_t_105; +typedef struct w32_VREvent_t_105 w32_VREvent_t_105; +typedef struct u64_VREvent_t_103 u64_VREvent_t_103; +typedef struct w64_VREvent_t_103 w64_VREvent_t_103; +typedef struct u32_VREvent_t_103 u32_VREvent_t_103; +typedef struct w32_VREvent_t_103 w32_VREvent_t_103; +typedef struct u64_VREvent_t_102 u64_VREvent_t_102; +typedef struct w64_VREvent_t_102 w64_VREvent_t_102; +typedef struct u32_VREvent_t_102 u32_VREvent_t_102; +typedef struct w32_VREvent_t_102 w32_VREvent_t_102; +typedef struct u64_VREvent_t_101 u64_VREvent_t_101; +typedef struct w64_VREvent_t_101 w64_VREvent_t_101; +typedef struct u32_VREvent_t_101 u32_VREvent_t_101; +typedef struct w32_VREvent_t_101 w32_VREvent_t_101; +typedef struct u64_VREvent_t_0918 u64_VREvent_t_0918; +typedef struct w64_VREvent_t_0918 w64_VREvent_t_0918; +typedef struct u32_VREvent_t_0918 u32_VREvent_t_0918; +typedef struct w32_VREvent_t_0918 w32_VREvent_t_0918; +typedef struct u64_VREvent_t_0915 u64_VREvent_t_0915; +typedef struct w64_VREvent_t_0915 w64_VREvent_t_0915; +typedef struct u32_VREvent_t_0915 u32_VREvent_t_0915; +typedef struct w32_VREvent_t_0915 w32_VREvent_t_0915; +typedef struct u64_VREvent_t_0914 u64_VREvent_t_0914; +typedef struct w64_VREvent_t_0914 w64_VREvent_t_0914; +typedef struct u32_VREvent_t_0914 u32_VREvent_t_0914; +typedef struct w32_VREvent_t_0914 w32_VREvent_t_0914; +typedef struct u64_VREvent_t_0912 u64_VREvent_t_0912; +typedef struct w64_VREvent_t_0912 w64_VREvent_t_0912; +typedef struct u32_VREvent_t_0912 u32_VREvent_t_0912; +typedef struct w32_VREvent_t_0912 w32_VREvent_t_0912; +typedef struct u64_VREvent_t_0910 u64_VREvent_t_0910; +typedef struct w64_VREvent_t_0910 w64_VREvent_t_0910; +typedef struct u32_VREvent_t_0910 u32_VREvent_t_0910; +typedef struct w32_VREvent_t_0910 w32_VREvent_t_0910; +typedef struct u64_VREvent_t_097 u64_VREvent_t_097; +typedef struct w64_VREvent_t_097 w64_VREvent_t_097; +typedef struct u32_VREvent_t_097 u32_VREvent_t_097; +typedef struct w32_VREvent_t_097 w32_VREvent_t_097; +typedef struct u64_VREvent_t_093 u64_VREvent_t_093; +typedef struct w64_VREvent_t_093 w64_VREvent_t_093; +typedef struct u32_VREvent_t_093 u32_VREvent_t_093; +typedef struct w32_VREvent_t_093 w32_VREvent_t_093; +typedef struct u64_VREvent_t_092 u64_VREvent_t_092; +typedef struct w64_VREvent_t_092 w64_VREvent_t_092; +typedef struct u32_VREvent_t_092 u32_VREvent_t_092; +typedef struct w32_VREvent_t_092 w32_VREvent_t_092; +typedef struct u64_VREvent_t_090 u64_VREvent_t_090; +typedef struct w64_VREvent_t_090 w64_VREvent_t_090; +typedef struct u32_VREvent_t_090 u32_VREvent_t_090; +typedef struct w32_VREvent_t_090 w32_VREvent_t_090; +typedef struct w64_VRNativeDevice_t u64_VRNativeDevice_t; +typedef struct w64_VRNativeDevice_t w64_VRNativeDevice_t; +typedef struct w32_VRNativeDevice_t u32_VRNativeDevice_t; +typedef struct w32_VRNativeDevice_t w32_VRNativeDevice_t; +typedef struct w64_VROverlayView_t u64_VROverlayView_t; +typedef struct w64_VROverlayView_t w64_VROverlayView_t; +typedef struct u32_VROverlayView_t u32_VROverlayView_t; +typedef struct w32_VROverlayView_t w32_VROverlayView_t; +typedef struct w64_VRTextureWithDepth_t u64_VRTextureWithDepth_t; +typedef struct w64_VRTextureWithDepth_t w64_VRTextureWithDepth_t; +typedef struct w32_VRTextureWithDepth_t u32_VRTextureWithDepth_t; +typedef struct w32_VRTextureWithDepth_t w32_VRTextureWithDepth_t; +typedef struct w64_VRTextureWithPoseAndDepth_t u64_VRTextureWithPoseAndDepth_t; +typedef struct w64_VRTextureWithPoseAndDepth_t w64_VRTextureWithPoseAndDepth_t; +typedef struct w32_VRTextureWithPoseAndDepth_t u32_VRTextureWithPoseAndDepth_t; +typedef struct w32_VRTextureWithPoseAndDepth_t w32_VRTextureWithPoseAndDepth_t; +typedef struct w64_VRTextureWithPose_t u64_VRTextureWithPose_t; +typedef struct w64_VRTextureWithPose_t w64_VRTextureWithPose_t; +typedef struct w32_VRTextureWithPose_t u32_VRTextureWithPose_t; +typedef struct w32_VRTextureWithPose_t w32_VRTextureWithPose_t; +typedef struct w64_VRVulkanDevice_t u64_VRVulkanDevice_t; +typedef struct w64_VRVulkanDevice_t w64_VRVulkanDevice_t; +typedef struct w32_VRVulkanDevice_t u32_VRVulkanDevice_t; +typedef struct w32_VRVulkanDevice_t w32_VRVulkanDevice_t; +typedef struct w64_VRVulkanTextureArrayData_t u64_VRVulkanTextureArrayData_t; +typedef struct w64_VRVulkanTextureArrayData_t w64_VRVulkanTextureArrayData_t; +typedef struct u32_VRVulkanTextureArrayData_t u32_VRVulkanTextureArrayData_t; +typedef struct w32_VRVulkanTextureArrayData_t w32_VRVulkanTextureArrayData_t; +typedef struct w64_VRVulkanTextureData_t u64_VRVulkanTextureData_t; +typedef struct w64_VRVulkanTextureData_t w64_VRVulkanTextureData_t; +typedef struct w32_VRVulkanTextureData_t u32_VRVulkanTextureData_t; +typedef struct w32_VRVulkanTextureData_t w32_VRVulkanTextureData_t; +typedef struct w64_VulkanData_t u64_VulkanData_t; +typedef struct w64_VulkanData_t w64_VulkanData_t; +typedef struct w32_VulkanData_t u32_VulkanData_t; +typedef struct w32_VulkanData_t w32_VulkanData_t; +#pragma pack( push, 8 ) +struct w64_RenderModel_TextureMap_t_1237 +{ + uint16_t unWidth; + uint16_t unHeight; + uint8_t __pad_4[4]; + W64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; + uint16_t unMipLevels; + uint8_t __pad_22[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RenderModel_TextureMap_t_1237 +{ + uint16_t unWidth; + uint16_t unHeight; + U64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; + uint16_t unMipLevels; + uint8_t __pad_18[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RenderModel_TextureMap_t_1237 +{ + uint16_t unWidth; + uint16_t unHeight; + W32_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; + uint16_t unMipLevels; + uint8_t __pad_14[2]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RenderModel_TextureMap_t_1237 w_RenderModel_TextureMap_t_1237; +typedef u32_RenderModel_TextureMap_t_1237 u_RenderModel_TextureMap_t_1237; +#endif +#ifdef __x86_64__ +typedef w64_RenderModel_TextureMap_t_1237 w_RenderModel_TextureMap_t_1237; +typedef u64_RenderModel_TextureMap_t_1237 u_RenderModel_TextureMap_t_1237; +#endif + +#pragma pack( push, 8 ) +struct w64_RenderModel_TextureMap_t_11111 +{ + uint16_t unWidth; + uint16_t unHeight; + uint8_t __pad_4[4]; + W64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RenderModel_TextureMap_t_11111 +{ + uint16_t unWidth; + uint16_t unHeight; + U64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RenderModel_TextureMap_t_11111 +{ + uint16_t unWidth; + uint16_t unHeight; + W32_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); + uint32_t format; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RenderModel_TextureMap_t_11111 w_RenderModel_TextureMap_t_11111; +typedef u32_RenderModel_TextureMap_t_11111 u_RenderModel_TextureMap_t_11111; +#endif +#ifdef __x86_64__ +typedef w64_RenderModel_TextureMap_t_11111 w_RenderModel_TextureMap_t_11111; +typedef u64_RenderModel_TextureMap_t_11111 u_RenderModel_TextureMap_t_11111; +#endif + +#pragma pack( push, 8 ) +struct w64_RenderModel_TextureMap_t_090 +{ + uint16_t unWidth; + uint16_t unHeight; + uint8_t __pad_4[4]; + W64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RenderModel_TextureMap_t_090 +{ + uint16_t unWidth; + uint16_t unHeight; + U64_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RenderModel_TextureMap_t_090 +{ + uint16_t unWidth; + uint16_t unHeight; + W32_PTR(const uint8_t *rubTextureMapData, rubTextureMapData); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RenderModel_TextureMap_t_090 w_RenderModel_TextureMap_t_090; +typedef u32_RenderModel_TextureMap_t_090 u_RenderModel_TextureMap_t_090; +#endif +#ifdef __x86_64__ +typedef w64_RenderModel_TextureMap_t_090 w_RenderModel_TextureMap_t_090; +typedef u64_RenderModel_TextureMap_t_090 u_RenderModel_TextureMap_t_090; +#endif + +#pragma pack( push, 8 ) +struct w64_Texture_t +{ + W64_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_Texture_t +{ + W32_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Texture_t w_Texture_t; +typedef u32_Texture_t u_Texture_t; +#endif +#ifdef __x86_64__ +typedef w64_Texture_t w_Texture_t; +typedef u64_Texture_t u_Texture_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRTextureDepthInfo_t +{ + W64_PTR(void *handle, handle); + HmdMatrix44_t mProjection; + HmdVector2_t vRange; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRTextureDepthInfo_t +{ + W32_PTR(void *handle, handle); + HmdMatrix44_t mProjection; + HmdVector2_t vRange; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRTextureDepthInfo_t w_VRTextureDepthInfo_t; +typedef u32_VRTextureDepthInfo_t u_VRTextureDepthInfo_t; +#endif +#ifdef __x86_64__ +typedef w64_VRTextureDepthInfo_t w_VRTextureDepthInfo_t; +typedef u64_VRTextureDepthInfo_t u_VRTextureDepthInfo_t; +#endif + +#pragma pack( push, 8 ) +struct w64_AppOverrideKeys_t +{ + W64_PTR(const char *pchKey, pchKey); + W64_PTR(const char *pchValue, pchValue); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_AppOverrideKeys_t +{ + W32_PTR(const char *pchKey, pchKey); + W32_PTR(const char *pchValue, pchValue); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_AppOverrideKeys_t w_AppOverrideKeys_t; +typedef u32_AppOverrideKeys_t u_AppOverrideKeys_t; +#endif +#ifdef __x86_64__ +typedef w64_AppOverrideKeys_t w_AppOverrideKeys_t; +typedef u64_AppOverrideKeys_t u_AppOverrideKeys_t; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_11030 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVRHeadsetView*/ *m_pVRHeadsetView, m_pVRHeadsetView); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVROverlayView*/ *m_pVROverlayView, m_pVROverlayView); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W64_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W64_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W64_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W64_PTR(void /*IVRDebug*/ *m_pVRDebug, m_pVRDebug); + W64_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_11030 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVRHeadsetView*/ *m_pVRHeadsetView, m_pVRHeadsetView); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVROverlayView*/ *m_pVROverlayView, m_pVROverlayView); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W32_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W32_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W32_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W32_PTR(void /*IVRDebug*/ *m_pVRDebug, m_pVRDebug); + W32_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_11030 w_COpenVRContext_11030; +typedef u32_COpenVRContext_11030 u_COpenVRContext_11030; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_11030 w_COpenVRContext_11030; +typedef u64_COpenVRContext_11030 u_COpenVRContext_11030; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_1517 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W64_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W64_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W64_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W64_PTR(void /*IVRDebug*/ *m_pVRDebug, m_pVRDebug); + W64_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_1517 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W32_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W32_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W32_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W32_PTR(void /*IVRDebug*/ *m_pVRDebug, m_pVRDebug); + W32_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_1517 w_COpenVRContext_1517; +typedef u32_COpenVRContext_1517 u_COpenVRContext_1517; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_1517 w_COpenVRContext_1517; +typedef u64_COpenVRContext_1517 u_COpenVRContext_1517; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_1210 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W64_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W64_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W64_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W64_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_1210 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W32_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W32_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W32_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); + W32_PTR(void /*IVRNotifications*/ *m_pVRNotifications, m_pVRNotifications); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_1210 w_COpenVRContext_1210; +typedef u32_COpenVRContext_1210 u_COpenVRContext_1210; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_1210 w_COpenVRContext_1210; +typedef u64_COpenVRContext_1210 u_COpenVRContext_1210; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_1016 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W64_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W64_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W64_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_1016 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W32_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W32_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); + W32_PTR(void /*IVRSpatialAnchors*/ *m_pVRSpatialAnchors, m_pVRSpatialAnchors); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_1016 w_COpenVRContext_1016; +typedef u32_COpenVRContext_1016 u_COpenVRContext_1016; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_1016 w_COpenVRContext_1016; +typedef u64_COpenVRContext_1016 u_COpenVRContext_1016; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_1015 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W64_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W64_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_1015 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); + W32_PTR(void /*IVRInput*/ *m_pVRInput, m_pVRInput); + W32_PTR(void /*IVRIOBuffer*/ *m_pVRIOBuffer, m_pVRIOBuffer); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_1015 w_COpenVRContext_1015; +typedef u32_COpenVRContext_1015 u_COpenVRContext_1015; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_1015 w_COpenVRContext_1015; +typedef u64_COpenVRContext_1015 u_COpenVRContext_1015; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_108 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W64_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_108 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); + W32_PTR(void /*IVRDriverManager*/ *m_pVRDriverManager, m_pVRDriverManager); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_108 w_COpenVRContext_108; +typedef u32_COpenVRContext_108 u_COpenVRContext_108; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_108 w_COpenVRContext_108; +typedef u64_COpenVRContext_108 u_COpenVRContext_108; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_102 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_102 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRResources*/ *m_pVRResources, m_pVRResources); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_102 w_COpenVRContext_102; +typedef u32_COpenVRContext_102 u_COpenVRContext_102; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_102 w_COpenVRContext_102; +typedef u64_COpenVRContext_102 u_COpenVRContext_102; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_101 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W64_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_101 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); + W32_PTR(void /*IVRScreenshots*/ *m_pVRScreenshots, m_pVRScreenshots); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_101 w_COpenVRContext_101; +typedef u32_COpenVRContext_101 u_COpenVRContext_101; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_101 w_COpenVRContext_101; +typedef u64_COpenVRContext_101 u_COpenVRContext_101; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_100 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W64_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_100 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); + W32_PTR(void /*IVRTrackedCamera*/ *m_pVRTrackedCamera, m_pVRTrackedCamera); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_100 w_COpenVRContext_100; +typedef u32_COpenVRContext_100 u_COpenVRContext_100; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_100 w_COpenVRContext_100; +typedef u64_COpenVRContext_100 u_COpenVRContext_100; +#endif + +#pragma pack( push, 8 ) +struct w64_COpenVRContext_0917 +{ + W64_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W64_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W64_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W64_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W64_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W64_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W64_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W64_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W64_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_COpenVRContext_0917 +{ + W32_PTR(void /*IVRSystem*/ *m_pVRSystem, m_pVRSystem); + W32_PTR(void /*IVRChaperone*/ *m_pVRChaperone, m_pVRChaperone); + W32_PTR(void /*IVRChaperoneSetup*/ *m_pVRChaperoneSetup, m_pVRChaperoneSetup); + W32_PTR(void /*IVRCompositor*/ *m_pVRCompositor, m_pVRCompositor); + W32_PTR(void /*IVROverlay*/ *m_pVROverlay, m_pVROverlay); + W32_PTR(void /*IVRRenderModels*/ *m_pVRRenderModels, m_pVRRenderModels); + W32_PTR(void /*IVRExtendedDisplay*/ *m_pVRExtendedDisplay, m_pVRExtendedDisplay); + W32_PTR(void /*IVRSettings*/ *m_pVRSettings, m_pVRSettings); + W32_PTR(void /*IVRApplications*/ *m_pVRApplications, m_pVRApplications); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_COpenVRContext_0917 w_COpenVRContext_0917; +typedef u32_COpenVRContext_0917 u_COpenVRContext_0917; +#endif +#ifdef __x86_64__ +typedef w64_COpenVRContext_0917 w_COpenVRContext_0917; +typedef u64_COpenVRContext_0917 u_COpenVRContext_0917; +#endif + +#pragma pack( push, 8 ) +struct w64_CameraVideoStreamFrameHeader_t_1017 +{ + uint32_t eFrameType; + uint32_t nWidth; + uint32_t nHeight; + uint32_t nBytesPerPixel; + uint32_t nFrameSequence; + TrackedDevicePose_t trackedDevicePose; + uint8_t __pad_100[4]; + uint64_t ulFrameExposureTime; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_CameraVideoStreamFrameHeader_t_1017 +{ + uint32_t eFrameType; + uint32_t nWidth; + uint32_t nHeight; + uint32_t nBytesPerPixel; + uint32_t nFrameSequence; + TrackedDevicePose_t trackedDevicePose; + uint8_t __pad_100[4]; + uint64_t ulFrameExposureTime; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_CameraVideoStreamFrameHeader_t_1017 +{ + uint32_t eFrameType; + uint32_t nWidth; + uint32_t nHeight; + uint32_t nBytesPerPixel; + uint32_t nFrameSequence; + TrackedDevicePose_t trackedDevicePose; + uint64_t ulFrameExposureTime; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CameraVideoStreamFrameHeader_t_1017 w_CameraVideoStreamFrameHeader_t_1017; +typedef u32_CameraVideoStreamFrameHeader_t_1017 u_CameraVideoStreamFrameHeader_t_1017; +#endif +#ifdef __x86_64__ +typedef w64_CameraVideoStreamFrameHeader_t_1017 w_CameraVideoStreamFrameHeader_t_1017; +typedef u64_CameraVideoStreamFrameHeader_t_1017 u_CameraVideoStreamFrameHeader_t_1017; +#endif + +#pragma pack( push, 4 ) +struct w64_CameraVideoStreamFrameHeader_t_100 +{ + uint32_t eFrameType; + uint32_t nWidth; + uint32_t nHeight; + uint32_t nBytesPerPixel; + uint32_t nFrameSequence; + TrackedDevicePose_t standingTrackedDevicePose; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CameraVideoStreamFrameHeader_t_100 +{ + uint32_t eFrameType; + uint32_t nWidth; + uint32_t nHeight; + uint32_t nBytesPerPixel; + uint32_t nFrameSequence; + TrackedDevicePose_t standingTrackedDevicePose; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CameraVideoStreamFrameHeader_t_100 w_CameraVideoStreamFrameHeader_t_100; +typedef u32_CameraVideoStreamFrameHeader_t_100 u_CameraVideoStreamFrameHeader_t_100; +#endif +#ifdef __x86_64__ +typedef w64_CameraVideoStreamFrameHeader_t_100 w_CameraVideoStreamFrameHeader_t_100; +typedef u64_CameraVideoStreamFrameHeader_t_100 u_CameraVideoStreamFrameHeader_t_100; +#endif + +#pragma pack( push, 8 ) +struct w64_CameraVideoStreamFrame_t_0914 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nImageDataSize; + uint32_t m_nFrameSequence; + uint32_t m_nISPFrameTimeStamp; + uint32_t m_nISPReferenceTimeStamp; + uint32_t m_nSyncCounter; + uint32_t m_nExposureTime; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + uint8_t __pad_44[4]; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + uint64_t m_nFrameCaptureTicks; + bool m_bPoseIsValid; + uint8_t __pad_73[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + W64_ARRAY(float, 4, m_Pad); + uint8_t __pad_140[4]; + W64_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_CameraVideoStreamFrame_t_0914 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nImageDataSize; + uint32_t m_nFrameSequence; + uint32_t m_nISPFrameTimeStamp; + uint32_t m_nISPReferenceTimeStamp; + uint32_t m_nSyncCounter; + uint32_t m_nExposureTime; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + uint64_t m_nFrameCaptureTicks; + bool m_bPoseIsValid; + uint8_t __pad_69[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + U64_ARRAY(float, 4, m_Pad); + U64_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_CameraVideoStreamFrame_t_0914 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nImageDataSize; + uint32_t m_nFrameSequence; + uint32_t m_nISPFrameTimeStamp; + uint32_t m_nISPReferenceTimeStamp; + uint32_t m_nSyncCounter; + uint32_t m_nExposureTime; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + uint8_t __pad_44[4]; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + uint64_t m_nFrameCaptureTicks; + bool m_bPoseIsValid; + uint8_t __pad_73[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + W32_ARRAY(float, 4, m_Pad); + W32_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_CameraVideoStreamFrame_t_0914 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nImageDataSize; + uint32_t m_nFrameSequence; + uint32_t m_nISPFrameTimeStamp; + uint32_t m_nISPReferenceTimeStamp; + uint32_t m_nSyncCounter; + uint32_t m_nExposureTime; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + uint64_t m_nFrameCaptureTicks; + bool m_bPoseIsValid; + uint8_t __pad_69[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + U32_ARRAY(float, 4, m_Pad); + U32_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CameraVideoStreamFrame_t_0914 w_CameraVideoStreamFrame_t_0914; +typedef u32_CameraVideoStreamFrame_t_0914 u_CameraVideoStreamFrame_t_0914; +#endif +#ifdef __x86_64__ +typedef w64_CameraVideoStreamFrame_t_0914 w_CameraVideoStreamFrame_t_0914; +typedef u64_CameraVideoStreamFrame_t_0914 u_CameraVideoStreamFrame_t_0914; +#endif + +#pragma pack( push, 8 ) +struct w64_CameraVideoStreamFrame_t_0912 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFrameSequence; + uint32_t m_nTimeStamp; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + uint32_t m_nImageDataSize; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + bool m_bPoseIsValid; + uint8_t __pad_49[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + W64_ARRAY(float, 4, m_Pad); + uint8_t __pad_116[4]; + W64_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_CameraVideoStreamFrame_t_0912 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFrameSequence; + uint32_t m_nTimeStamp; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + uint32_t m_nImageDataSize; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + bool m_bPoseIsValid; + uint8_t __pad_49[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + U64_ARRAY(float, 4, m_Pad); + U64_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_CameraVideoStreamFrame_t_0912 +{ + uint32_t m_nStreamFormat; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFrameSequence; + uint32_t m_nTimeStamp; + uint32_t m_nBufferIndex; + uint32_t m_nBufferCount; + uint32_t m_nImageDataSize; + double m_flFrameElapsedTime; + double m_flFrameCaptureTime; + bool m_bPoseIsValid; + uint8_t __pad_49[3]; + HmdMatrix34_t m_matDeviceToAbsoluteTracking; + W32_ARRAY(float, 4, m_Pad); + W32_PTR(void *m_pImageData, m_pImageData); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CameraVideoStreamFrame_t_0912 w_CameraVideoStreamFrame_t_0912; +typedef u32_CameraVideoStreamFrame_t_0912 u_CameraVideoStreamFrame_t_0912; +#endif +#ifdef __x86_64__ +typedef w64_CameraVideoStreamFrame_t_0912 w_CameraVideoStreamFrame_t_0912; +typedef u64_CameraVideoStreamFrame_t_0912 u_CameraVideoStreamFrame_t_0912; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_1017 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + uint32_t m_nNumVSyncsReadyForUse; + uint32_t m_nNumVSyncsToFirstView; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_1017 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + uint32_t m_nNumVSyncsReadyForUse; + uint32_t m_nNumVSyncsToFirstView; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_1017 w_Compositor_FrameTiming_1017; +typedef u32_Compositor_FrameTiming_1017 u_Compositor_FrameTiming_1017; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_1017 w_Compositor_FrameTiming_1017; +typedef u64_Compositor_FrameTiming_1017 u_Compositor_FrameTiming_1017; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_103a +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_103a +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_103a w_Compositor_FrameTiming_103a; +typedef u32_Compositor_FrameTiming_103a u_Compositor_FrameTiming_103a; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_103a w_Compositor_FrameTiming_103a; +typedef u64_Compositor_FrameTiming_103a u_Compositor_FrameTiming_103a; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_102 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + uint8_t __pad_20[4]; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_102 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_102 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + uint8_t __pad_20[4]; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_102 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + uint32_t m_nReprojectionFlags; + double m_flSystemTimeInSeconds; + float m_flPreSubmitGpuMs; + float m_flPostSubmitGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_102 w_Compositor_FrameTiming_102; +typedef u32_Compositor_FrameTiming_102 u_Compositor_FrameTiming_102; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_102 w_Compositor_FrameTiming_102; +typedef u64_Compositor_FrameTiming_102 u_Compositor_FrameTiming_102; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_0920 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + double m_flSystemTimeInSeconds; + float m_flSceneRenderGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + int32_t m_nFidelityLevel; + uint32_t m_nReprojectionFlags; + uint8_t __pad_172[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_0920 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + double m_flSystemTimeInSeconds; + float m_flSceneRenderGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + int32_t m_nFidelityLevel; + uint32_t m_nReprojectionFlags; + uint8_t __pad_172[4]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_0920 w_Compositor_FrameTiming_0920; +typedef u32_Compositor_FrameTiming_0920 u_Compositor_FrameTiming_0920; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_0920 w_Compositor_FrameTiming_0920; +typedef u64_Compositor_FrameTiming_0920 u_Compositor_FrameTiming_0920; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_0915 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + double m_flSystemTimeInSeconds; + float m_flSceneRenderGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + int32_t m_nFidelityLevel; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_0915 +{ + uint32_t m_nSize; + uint32_t m_nFrameIndex; + uint32_t m_nNumFramePresents; + uint32_t m_nNumDroppedFrames; + double m_flSystemTimeInSeconds; + float m_flSceneRenderGpuMs; + float m_flTotalRenderGpuMs; + float m_flCompositorRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorIdleCpuMs; + float m_flClientFrameIntervalMs; + float m_flPresentCallCpuMs; + float m_flWaitForPresentCpuMs; + float m_flSubmitFrameMs; + float m_flWaitGetPosesCalledMs; + float m_flNewPosesReadyMs; + float m_flNewFrameReadyMs; + float m_flCompositorUpdateStartMs; + float m_flCompositorUpdateEndMs; + float m_flCompositorRenderStartMs; + TrackedDevicePose_t m_HmdPose; + int32_t m_nFidelityLevel; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_0915 w_Compositor_FrameTiming_0915; +typedef u32_Compositor_FrameTiming_0915 u_Compositor_FrameTiming_0915; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_0915 w_Compositor_FrameTiming_0915; +typedef u64_Compositor_FrameTiming_0915 u_Compositor_FrameTiming_0915; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_0914 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; + uint32_t m_nPresents; + uint8_t __pad_156[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_0914 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; + uint32_t m_nPresents; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_0914 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; + uint32_t m_nPresents; + uint8_t __pad_156[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_0914 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; + uint32_t m_nPresents; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_0914 w_Compositor_FrameTiming_0914; +typedef u32_Compositor_FrameTiming_0914 u_Compositor_FrameTiming_0914; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_0914 w_Compositor_FrameTiming_0914; +typedef u64_Compositor_FrameTiming_0914 u_Compositor_FrameTiming_0914; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_0913 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_0913 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_0913 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_0913 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + float m_flCompositorUpdateCpuMs; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_0913 w_Compositor_FrameTiming_0913; +typedef u32_Compositor_FrameTiming_0913 u_Compositor_FrameTiming_0913; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_0913 w_Compositor_FrameTiming_0913; +typedef u64_Compositor_FrameTiming_0913 u_Compositor_FrameTiming_0913; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_0912 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + uint8_t __pad_148[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_0912 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_0912 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; + uint8_t __pad_148[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_0912 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + float m_flHandoffStartMs; + float m_flHandoffEndMs; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_0912 w_Compositor_FrameTiming_0912; +typedef u32_Compositor_FrameTiming_0912 u_Compositor_FrameTiming_0912; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_0912 w_Compositor_FrameTiming_0912; +typedef u64_Compositor_FrameTiming_0912 u_Compositor_FrameTiming_0912; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_093 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + uint8_t __pad_140[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_093 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_093 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; + uint8_t __pad_140[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_093 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + float prediction; + float m_flFrameIntervalMs; + float m_flSceneRenderCpuMs; + float m_flSceneRenderGpuMs; + float m_flCompositorRenderCpuMs; + float m_flCompositorRenderGpuMs; + float m_flPresentCallCpuMs; + float m_flRunningStartMs; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_093 w_Compositor_FrameTiming_093; +typedef u32_Compositor_FrameTiming_093 u_Compositor_FrameTiming_093; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_093 w_Compositor_FrameTiming_093; +typedef u64_Compositor_FrameTiming_093 u_Compositor_FrameTiming_093; +#endif + +#pragma pack( push, 8 ) +struct w64_Compositor_FrameTiming_090 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + uint8_t __pad_108[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_Compositor_FrameTiming_090 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_Compositor_FrameTiming_090 +{ + uint32_t size; + uint8_t __pad_4[4]; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; + uint8_t __pad_108[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_Compositor_FrameTiming_090 +{ + uint32_t size; + double frameStart; + float frameVSync; + uint32_t droppedFrames; + uint32_t frameIndex; + TrackedDevicePose_t pose; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_Compositor_FrameTiming_090 w_Compositor_FrameTiming_090; +typedef u32_Compositor_FrameTiming_090 u_Compositor_FrameTiming_090; +#endif +#ifdef __x86_64__ +typedef w64_Compositor_FrameTiming_090 w_Compositor_FrameTiming_090; +typedef u64_Compositor_FrameTiming_090 u_Compositor_FrameTiming_090; +#endif + +#pragma pack( push, 8 ) +struct w64_D3D12TextureData_t +{ + W64_PTR(void /*ID3D12Resource*/ *m_pResource, m_pResource); + W64_PTR(void /*ID3D12CommandQueue*/ *m_pCommandQueue, m_pCommandQueue); + uint32_t m_nNodeMask; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_D3D12TextureData_t +{ + W32_PTR(void /*ID3D12Resource*/ *m_pResource, m_pResource); + W32_PTR(void /*ID3D12CommandQueue*/ *m_pCommandQueue, m_pCommandQueue); + uint32_t m_nNodeMask; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_D3D12TextureData_t w_D3D12TextureData_t; +typedef u32_D3D12TextureData_t u_D3D12TextureData_t; +#endif +#ifdef __x86_64__ +typedef w64_D3D12TextureData_t w_D3D12TextureData_t; +typedef u64_D3D12TextureData_t u_D3D12TextureData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HiddenAreaMesh_t +{ + W64_PTR(const HmdVector2_t *pVertexData, pVertexData); + uint32_t unTriangleCount; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HiddenAreaMesh_t +{ + W32_PTR(const HmdVector2_t *pVertexData, pVertexData); + uint32_t unTriangleCount; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HiddenAreaMesh_t w_HiddenAreaMesh_t; +typedef u32_HiddenAreaMesh_t u_HiddenAreaMesh_t; +#endif +#ifdef __x86_64__ +typedef w64_HiddenAreaMesh_t w_HiddenAreaMesh_t; +typedef u64_HiddenAreaMesh_t u_HiddenAreaMesh_t; +#endif + +struct w_IVRDebug_IVRDebug_001 +{ +#ifdef __cplusplus + virtual uint32_t EmitVrProfilerEvent( const char * ) = 0; + virtual uint32_t BeginVrProfilerEvent( uint64_t * ) = 0; + virtual uint32_t FinishVrProfilerEvent( uint64_t, const char * ) = 0; + virtual uint32_t DriverDebugRequest( uint32_t, const char *, char *, uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct u_IVRDebug_IVRDebug_001 +{ +#ifdef __cplusplus + virtual uint32_t EmitVrProfilerEvent( const char * ) = 0; + virtual uint32_t BeginVrProfilerEvent( uint64_t * ) = 0; + virtual uint32_t FinishVrProfilerEvent( uint64_t, const char * ) = 0; + virtual uint32_t DriverDebugRequest( uint32_t, const char *, char *, uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct w_IVRSpatialAnchors_IVRSpatialAnchors_001 +{ +#ifdef __cplusplus + virtual uint32_t CreateSpatialAnchorFromDescriptor( const char *, uint32_t * ) = 0; + virtual uint32_t CreateSpatialAnchorFromPose( uint32_t, uint32_t, SpatialAnchorPose_t *, uint32_t * ) = 0; + virtual uint32_t GetSpatialAnchorPose( uint32_t, uint32_t, SpatialAnchorPose_t * ) = 0; + virtual uint32_t GetSpatialAnchorDescriptor( uint32_t, char *, uint32_t * ) = 0; +#endif /* __cplusplus */ +}; + +struct u_IVRSpatialAnchors_IVRSpatialAnchors_001 +{ +#ifdef __cplusplus + virtual uint32_t CreateSpatialAnchorFromDescriptor( const char *, uint32_t * ) = 0; + virtual uint32_t CreateSpatialAnchorFromPose( uint32_t, uint32_t, SpatialAnchorPose_t *, uint32_t * ) = 0; + virtual uint32_t GetSpatialAnchorPose( uint32_t, uint32_t, SpatialAnchorPose_t * ) = 0; + virtual uint32_t GetSpatialAnchorDescriptor( uint32_t, char *, uint32_t * ) = 0; +#endif /* __cplusplus */ +}; + +#pragma pack( push, 8 ) +struct w64_InputAnalogActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + float x; + float y; + float z; + float deltaX; + float deltaY; + float deltaZ; + float fUpdateTime; + uint8_t __pad_44[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputAnalogActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + float x; + float y; + float z; + float deltaX; + float deltaY; + float deltaZ; + float fUpdateTime; + uint8_t __pad_44[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputAnalogActionData_t +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; + float x; + float y; + float z; + float deltaX; + float deltaY; + float deltaZ; + float fUpdateTime; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputAnalogActionData_t w_InputAnalogActionData_t; +typedef u32_InputAnalogActionData_t u_InputAnalogActionData_t; +#endif +#ifdef __x86_64__ +typedef w64_InputAnalogActionData_t w_InputAnalogActionData_t; +typedef u64_InputAnalogActionData_t u_InputAnalogActionData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_InputDigitalActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + bool bState; + bool bChanged; + uint8_t __pad_18[2]; + float fUpdateTime; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputDigitalActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + bool bState; + bool bChanged; + uint8_t __pad_18[2]; + float fUpdateTime; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputDigitalActionData_t +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; + bool bState; + bool bChanged; + uint8_t __pad_14[2]; + float fUpdateTime; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputDigitalActionData_t w_InputDigitalActionData_t; +typedef u32_InputDigitalActionData_t u_InputDigitalActionData_t; +#endif +#ifdef __x86_64__ +typedef w64_InputDigitalActionData_t w_InputDigitalActionData_t; +typedef u64_InputDigitalActionData_t u_InputDigitalActionData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_InputOriginInfo_t +{ + uint64_t devicePath; + uint32_t trackedDeviceIndex; + W64_ARRAY(char, 128, rchRenderModelComponentName); + uint8_t __pad_140[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputOriginInfo_t +{ + uint64_t devicePath; + uint32_t trackedDeviceIndex; + W32_ARRAY(char, 128, rchRenderModelComponentName); + uint8_t __pad_140[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputOriginInfo_t +{ + uint64_t devicePath; + uint32_t trackedDeviceIndex; + U32_ARRAY(char, 128, rchRenderModelComponentName); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputOriginInfo_t w_InputOriginInfo_t; +typedef u32_InputOriginInfo_t u_InputOriginInfo_t; +#endif +#ifdef __x86_64__ +typedef w64_InputOriginInfo_t w_InputOriginInfo_t; +typedef u64_InputOriginInfo_t u_InputOriginInfo_t; +#endif + +#pragma pack( push, 8 ) +struct w64_InputPoseActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + TrackedDevicePose_t pose; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputPoseActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + TrackedDevicePose_t pose; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputPoseActionData_t +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; + TrackedDevicePose_t pose; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputPoseActionData_t w_InputPoseActionData_t; +typedef u32_InputPoseActionData_t u_InputPoseActionData_t; +#endif +#ifdef __x86_64__ +typedef w64_InputPoseActionData_t w_InputPoseActionData_t; +typedef u64_InputPoseActionData_t u_InputPoseActionData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_InputSkeletalActionData_t_113b +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputSkeletalActionData_t_113b +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputSkeletalActionData_t_113b +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputSkeletalActionData_t_113b w_InputSkeletalActionData_t_113b; +typedef u32_InputSkeletalActionData_t_113b u_InputSkeletalActionData_t_113b; +#endif +#ifdef __x86_64__ +typedef w64_InputSkeletalActionData_t_113b w_InputSkeletalActionData_t_113b; +typedef u64_InputSkeletalActionData_t_113b u_InputSkeletalActionData_t_113b; +#endif + +#pragma pack( push, 8 ) +struct w64_InputSkeletalActionData_t_1016 +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + uint32_t boneCount; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputSkeletalActionData_t_1016 +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; + uint32_t boneCount; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputSkeletalActionData_t_1016 +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; + uint32_t boneCount; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputSkeletalActionData_t_1016 w_InputSkeletalActionData_t_1016; +typedef u32_InputSkeletalActionData_t_1016 u_InputSkeletalActionData_t_1016; +#endif +#ifdef __x86_64__ +typedef w64_InputSkeletalActionData_t_1016 w_InputSkeletalActionData_t_1016; +typedef u64_InputSkeletalActionData_t_1016 u_InputSkeletalActionData_t_1016; +#endif + +#pragma pack( push, 8 ) +struct w64_InputSkeletonActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_InputSkeletonActionData_t +{ + bool bActive; + uint8_t __pad_1[7]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_InputSkeletonActionData_t +{ + bool bActive; + uint8_t __pad_1[3]; + uint64_t activeOrigin; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_InputSkeletonActionData_t w_InputSkeletonActionData_t; +typedef u32_InputSkeletonActionData_t u_InputSkeletonActionData_t; +#endif +#ifdef __x86_64__ +typedef w64_InputSkeletonActionData_t w_InputSkeletonActionData_t; +typedef u64_InputSkeletonActionData_t u_InputSkeletonActionData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_NotificationBitmap +{ + W64_PTR(void *bytes, bytes); + int32_t width; + int32_t height; + int32_t depth; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_NotificationBitmap +{ + W32_PTR(void *bytes, bytes); + int32_t width; + int32_t height; + int32_t depth; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_NotificationBitmap w_NotificationBitmap; +typedef u32_NotificationBitmap u_NotificationBitmap; +#endif +#ifdef __x86_64__ +typedef w64_NotificationBitmap w_NotificationBitmap; +typedef u64_NotificationBitmap u_NotificationBitmap; +#endif + +#pragma pack( push, 8 ) +struct w64_NotificationBitmap_t +{ + W64_PTR(void *m_pImageData, m_pImageData); + int32_t m_nWidth; + int32_t m_nHeight; + int32_t m_nBytesPerPixel; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_NotificationBitmap_t +{ + W32_PTR(void *m_pImageData, m_pImageData); + int32_t m_nWidth; + int32_t m_nHeight; + int32_t m_nBytesPerPixel; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_NotificationBitmap_t w_NotificationBitmap_t; +typedef u32_NotificationBitmap_t u_NotificationBitmap_t; +#endif +#ifdef __x86_64__ +typedef w64_NotificationBitmap_t w_NotificationBitmap_t; +typedef u64_NotificationBitmap_t u_NotificationBitmap_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RenderModel_t_0912 +{ + W64_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + uint8_t __pad_12[4]; + W64_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + int32_t diffuseTextureId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RenderModel_t_0912 +{ + U64_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + U64_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + int32_t diffuseTextureId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RenderModel_t_0912 +{ + W32_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + W32_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + int32_t diffuseTextureId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RenderModel_t_0912 w_RenderModel_t_0912; +typedef u32_RenderModel_t_0912 u_RenderModel_t_0912; +#endif +#ifdef __x86_64__ +typedef w64_RenderModel_t_0912 w_RenderModel_t_0912; +typedef u64_RenderModel_t_0912 u_RenderModel_t_0912; +#endif + +#pragma pack( push, 8 ) +struct w64_RenderModel_t_090 +{ + uint64_t ulInternalHandle; + W64_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + uint8_t __pad_20[4]; + W64_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + uint8_t __pad_36[4]; + w64_RenderModel_TextureMap_t_090 diffuseTexture; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RenderModel_t_090 +{ + uint64_t ulInternalHandle; + U64_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + U64_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + u64_RenderModel_TextureMap_t_090 diffuseTexture; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RenderModel_t_090 +{ + uint64_t ulInternalHandle; + W32_PTR(const RenderModel_Vertex_t *rVertexData, rVertexData); + uint32_t unVertexCount; + W32_PTR(const uint16_t *rIndexData, rIndexData); + uint32_t unTriangleCount; + w32_RenderModel_TextureMap_t_090 diffuseTexture; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RenderModel_t_090 w_RenderModel_t_090; +typedef u32_RenderModel_t_090 u_RenderModel_t_090; +#endif +#ifdef __x86_64__ +typedef w64_RenderModel_t_090 w_RenderModel_t_090; +typedef u64_RenderModel_t_090 u_RenderModel_t_090; +#endif + +#pragma pack( push, 8 ) +struct w64_VRControllerState001_t +{ + uint32_t unPacketNum; + uint8_t __pad_4[4]; + uint64_t ulButtonPressed; + uint64_t ulButtonTouched; + W64_ARRAY(VRControllerAxis_t, 5, rAxis); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VRControllerState001_t +{ + uint32_t unPacketNum; + uint64_t ulButtonPressed; + uint64_t ulButtonTouched; + U64_ARRAY(VRControllerAxis_t, 5, rAxis); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VRControllerState001_t +{ + uint32_t unPacketNum; + uint8_t __pad_4[4]; + uint64_t ulButtonPressed; + uint64_t ulButtonTouched; + W32_ARRAY(VRControllerAxis_t, 5, rAxis); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VRControllerState001_t +{ + uint32_t unPacketNum; + uint64_t ulButtonPressed; + uint64_t ulButtonTouched; + U32_ARRAY(VRControllerAxis_t, 5, rAxis); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRControllerState001_t w_VRControllerState001_t; +typedef u32_VRControllerState001_t u_VRControllerState001_t; +#endif +#ifdef __x86_64__ +typedef w64_VRControllerState001_t w_VRControllerState001_t; +typedef u64_VRControllerState001_t u_VRControllerState001_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1168 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1168 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1168 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1168 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1168 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1168 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1168 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1168 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1168 w_VREvent_t_1168; +typedef u32_VREvent_t_1168 u_VREvent_t_1168; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1168 w_VREvent_t_1168; +typedef u64_VREvent_t_1168 u_VREvent_t_1168; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_11030 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_11030 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_11030 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_11030 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_11030 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_11030 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_11030 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_11030 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_11030 w_VREvent_t_11030; +typedef u32_VREvent_t_11030 u_VREvent_t_11030; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_11030 w_VREvent_t_11030; +typedef u64_VREvent_t_11030 u_VREvent_t_11030; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1322 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1322 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1322 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1322 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1322 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1322 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1322 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1322 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1322 w_VREvent_t_1322; +typedef u32_VREvent_t_1322 u_VREvent_t_1322; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1322 w_VREvent_t_1322; +typedef u64_VREvent_t_1322 u_VREvent_t_1322; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1210 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1210 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1210 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1210 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1210 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1210 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1210 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1210 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1210 w_VREvent_t_1210; +typedef u32_VREvent_t_1210 u_VREvent_t_1210; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1210 w_VREvent_t_1210; +typedef u64_VREvent_t_1210 u_VREvent_t_1210; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_113b +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_113b data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_113b +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_113b data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_113b +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_113b data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_113b +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_113b data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_113b w_VREvent_t_113b; +typedef u32_VREvent_t_113b u_VREvent_t_113b; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_113b w_VREvent_t_113b; +typedef u64_VREvent_t_113b u_VREvent_t_113b; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1016 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1016 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1016 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1016 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1016 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1016 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1016 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1016 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1016 w_VREvent_t_1016; +typedef u32_VREvent_t_1016 u_VREvent_t_1016; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1016 w_VREvent_t_1016; +typedef u64_VREvent_t_1016 u_VREvent_t_1016; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1015 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1015 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1015 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1015 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1015 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1015 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1015 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1015 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1015 w_VREvent_t_1015; +typedef u32_VREvent_t_1015 u_VREvent_t_1015; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1015 w_VREvent_t_1015; +typedef u64_VREvent_t_1015 u_VREvent_t_1015; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1014 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1014 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1014 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1014 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1014 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1014 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1014 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1014 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1014 w_VREvent_t_1014; +typedef u32_VREvent_t_1014 u_VREvent_t_1014; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1014 w_VREvent_t_1014; +typedef u64_VREvent_t_1014 u_VREvent_t_1014; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1013 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1013 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1013 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1013 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1013 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1013 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1013 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1013 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1013 w_VREvent_t_1013; +typedef u32_VREvent_t_1013 u_VREvent_t_1013; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1013 w_VREvent_t_1013; +typedef u64_VREvent_t_1013 u_VREvent_t_1013; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1012 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1012 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1012 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1012 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1012 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1012 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1012 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1012 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1012 w_VREvent_t_1012; +typedef u32_VREvent_t_1012 u_VREvent_t_1012; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1012 w_VREvent_t_1012; +typedef u64_VREvent_t_1012 u_VREvent_t_1012; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_1011 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1011 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_1011 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1011 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_1011 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_1011 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_1011 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_1011 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_1011 w_VREvent_t_1011; +typedef u32_VREvent_t_1011 u_VREvent_t_1011; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_1011 w_VREvent_t_1011; +typedef u64_VREvent_t_1011 u_VREvent_t_1011; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_106 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_106 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_106 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_106 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_106 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_106 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_106 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_106 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_106 w_VREvent_t_106; +typedef u32_VREvent_t_106 u_VREvent_t_106; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_106 w_VREvent_t_106; +typedef u64_VREvent_t_106 u_VREvent_t_106; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_105 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_105 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_105 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_105 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_105 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_105 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_105 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_105 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_105 w_VREvent_t_105; +typedef u32_VREvent_t_105 u_VREvent_t_105; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_105 w_VREvent_t_105; +typedef u64_VREvent_t_105 u_VREvent_t_105; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_103 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_103 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_103 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_103 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_103 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_103 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_103 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_103 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_103 w_VREvent_t_103; +typedef u32_VREvent_t_103 u_VREvent_t_103; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_103 w_VREvent_t_103; +typedef u64_VREvent_t_103 u_VREvent_t_103; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_102 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_102 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_102 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_102 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_102 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_102 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_102 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_102 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_102 w_VREvent_t_102; +typedef u32_VREvent_t_102 u_VREvent_t_102; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_102 w_VREvent_t_102; +typedef u64_VREvent_t_102 u_VREvent_t_102; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_101 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_101 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_101 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_101 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_101 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_101 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_101 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_101 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_101 w_VREvent_t_101; +typedef u32_VREvent_t_101 u_VREvent_t_101; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_101 w_VREvent_t_101; +typedef u64_VREvent_t_101 u_VREvent_t_101; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_0918 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_0918 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_0918 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_0918 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_0918 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_0918 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_0918 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_0918 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_0918 w_VREvent_t_0918; +typedef u32_VREvent_t_0918 u_VREvent_t_0918; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_0918 w_VREvent_t_0918; +typedef u64_VREvent_t_0918 u_VREvent_t_0918; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_0915 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_0915 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_0915 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_0915 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_0915 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + uint8_t __pad_12[4]; + VREvent_Data_t_0915 data; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_0915 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + float eventAgeSeconds; + VREvent_Data_t_0915 data; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_0915 w_VREvent_t_0915; +typedef u32_VREvent_t_0915 u_VREvent_t_0915; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_0915 w_VREvent_t_0915; +typedef u64_VREvent_t_0915 u_VREvent_t_0915; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_0914 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0914 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_0914 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0914 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_0914 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0914 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_0914 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0914 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_0914 w_VREvent_t_0914; +typedef u32_VREvent_t_0914 u_VREvent_t_0914; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_0914 w_VREvent_t_0914; +typedef u64_VREvent_t_0914 u_VREvent_t_0914; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_0912 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0912 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_0912 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0912 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_0912 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0912 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_0912 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0912 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_0912 w_VREvent_t_0912; +typedef u32_VREvent_t_0912 u_VREvent_t_0912; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_0912 w_VREvent_t_0912; +typedef u64_VREvent_t_0912 u_VREvent_t_0912; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_0910 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0910 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_0910 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0910 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_0910 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0910 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_0910 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_0910 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_0910 w_VREvent_t_0910; +typedef u32_VREvent_t_0910 u_VREvent_t_0910; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_0910 w_VREvent_t_0910; +typedef u64_VREvent_t_0910 u_VREvent_t_0910; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_097 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_097 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_097 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_097 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_097 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_097 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_097 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_097 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_097 w_VREvent_t_097; +typedef u32_VREvent_t_097 u_VREvent_t_097; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_097 w_VREvent_t_097; +typedef u64_VREvent_t_097 u_VREvent_t_097; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_093 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_093 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_093 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_093 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_093 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_093 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_093 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_093 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_093 w_VREvent_t_093; +typedef u32_VREvent_t_093 u_VREvent_t_093; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_093 w_VREvent_t_093; +typedef u64_VREvent_t_093 u_VREvent_t_093; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_092 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_092 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_092 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_092 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_092 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_092 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_092 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_092 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_092 w_VREvent_t_092; +typedef u32_VREvent_t_092 u_VREvent_t_092; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_092 w_VREvent_t_092; +typedef u64_VREvent_t_092 u_VREvent_t_092; +#endif + +#pragma pack( push, 8 ) +struct w64_VREvent_t_090 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_090 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_VREvent_t_090 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_090 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VREvent_t_090 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_090 data; + float eventAgeSeconds; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VREvent_t_090 +{ + uint32_t eventType; + uint32_t trackedDeviceIndex; + VREvent_Data_t_090 data; + float eventAgeSeconds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VREvent_t_090 w_VREvent_t_090; +typedef u32_VREvent_t_090 u_VREvent_t_090; +#endif +#ifdef __x86_64__ +typedef w64_VREvent_t_090 w_VREvent_t_090; +typedef u64_VREvent_t_090 u_VREvent_t_090; +#endif + +#pragma pack( push, 8 ) +struct w64_VRNativeDevice_t +{ + W64_PTR(void *handle, handle); + uint32_t eType; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRNativeDevice_t +{ + W32_PTR(void *handle, handle); + uint32_t eType; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRNativeDevice_t w_VRNativeDevice_t; +typedef u32_VRNativeDevice_t u_VRNativeDevice_t; +#endif +#ifdef __x86_64__ +typedef w64_VRNativeDevice_t w_VRNativeDevice_t; +typedef u64_VRNativeDevice_t u_VRNativeDevice_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VROverlayView_t +{ + uint64_t overlayHandle; + w64_Texture_t texture; + VRTextureBounds_t textureBounds; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VROverlayView_t +{ + uint64_t overlayHandle; + w32_Texture_t texture; + VRTextureBounds_t textureBounds; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VROverlayView_t +{ + uint64_t overlayHandle; + u32_Texture_t texture; + VRTextureBounds_t textureBounds; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VROverlayView_t w_VROverlayView_t; +typedef u32_VROverlayView_t u_VROverlayView_t; +#endif +#ifdef __x86_64__ +typedef w64_VROverlayView_t w_VROverlayView_t; +typedef u64_VROverlayView_t u_VROverlayView_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRTextureWithDepth_t +{ + W64_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + w64_VRTextureDepthInfo_t depth; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRTextureWithDepth_t +{ + W32_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + w32_VRTextureDepthInfo_t depth; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRTextureWithDepth_t w_VRTextureWithDepth_t; +typedef u32_VRTextureWithDepth_t u_VRTextureWithDepth_t; +#endif +#ifdef __x86_64__ +typedef w64_VRTextureWithDepth_t w_VRTextureWithDepth_t; +typedef u64_VRTextureWithDepth_t u_VRTextureWithDepth_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRTextureWithPoseAndDepth_t +{ + W64_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + HmdMatrix34_t mDeviceToAbsoluteTracking; + w64_VRTextureDepthInfo_t depth; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRTextureWithPoseAndDepth_t +{ + W32_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + HmdMatrix34_t mDeviceToAbsoluteTracking; + w32_VRTextureDepthInfo_t depth; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRTextureWithPoseAndDepth_t w_VRTextureWithPoseAndDepth_t; +typedef u32_VRTextureWithPoseAndDepth_t u_VRTextureWithPoseAndDepth_t; +#endif +#ifdef __x86_64__ +typedef w64_VRTextureWithPoseAndDepth_t w_VRTextureWithPoseAndDepth_t; +typedef u64_VRTextureWithPoseAndDepth_t u_VRTextureWithPoseAndDepth_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRTextureWithPose_t +{ + W64_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + HmdMatrix34_t mDeviceToAbsoluteTracking; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRTextureWithPose_t +{ + W32_PTR(void *handle, handle); + uint32_t eType; + uint32_t eColorSpace; + HmdMatrix34_t mDeviceToAbsoluteTracking; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRTextureWithPose_t w_VRTextureWithPose_t; +typedef u32_VRTextureWithPose_t u_VRTextureWithPose_t; +#endif +#ifdef __x86_64__ +typedef w64_VRTextureWithPose_t w_VRTextureWithPose_t; +typedef u64_VRTextureWithPose_t u_VRTextureWithPose_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRVulkanDevice_t +{ + W64_PTR(VkInstance_T *m_pInstance, m_pInstance); + W64_PTR(VkDevice_T *m_pDevice, m_pDevice); + W64_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W64_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_uQueueFamilyIndex; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_VRVulkanDevice_t +{ + W32_PTR(VkInstance_T *m_pInstance, m_pInstance); + W32_PTR(VkDevice_T *m_pDevice, m_pDevice); + W32_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W32_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_uQueueFamilyIndex; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRVulkanDevice_t w_VRVulkanDevice_t; +typedef u32_VRVulkanDevice_t u_VRVulkanDevice_t; +#endif +#ifdef __x86_64__ +typedef w64_VRVulkanDevice_t w_VRVulkanDevice_t; +typedef u64_VRVulkanDevice_t u_VRVulkanDevice_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRVulkanTextureArrayData_t +{ + uint64_t m_nImage; + W64_PTR(VkDevice_T *m_pDevice, m_pDevice); + W64_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W64_PTR(VkInstance_T *m_pInstance, m_pInstance); + W64_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_60[4]; + uint32_t m_unArrayIndex; + uint32_t m_unArraySize; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VRVulkanTextureArrayData_t +{ + uint64_t m_nImage; + W32_PTR(VkDevice_T *m_pDevice, m_pDevice); + W32_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W32_PTR(VkInstance_T *m_pInstance, m_pInstance); + W32_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_44[4]; + uint32_t m_unArrayIndex; + uint32_t m_unArraySize; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_VRVulkanTextureArrayData_t +{ + uint64_t m_nImage; + U32_PTR(VkDevice_T *m_pDevice, m_pDevice); + U32_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + U32_PTR(VkInstance_T *m_pInstance, m_pInstance); + U32_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint32_t m_unArrayIndex; + uint32_t m_unArraySize; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRVulkanTextureArrayData_t w_VRVulkanTextureArrayData_t; +typedef u32_VRVulkanTextureArrayData_t u_VRVulkanTextureArrayData_t; +#endif +#ifdef __x86_64__ +typedef w64_VRVulkanTextureArrayData_t w_VRVulkanTextureArrayData_t; +typedef u64_VRVulkanTextureArrayData_t u_VRVulkanTextureArrayData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VRVulkanTextureData_t +{ + uint64_t m_nImage; + W64_PTR(VkDevice_T *m_pDevice, m_pDevice); + W64_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W64_PTR(VkInstance_T *m_pInstance, m_pInstance); + W64_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_60[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VRVulkanTextureData_t +{ + uint64_t m_nImage; + W32_PTR(VkDevice_T *m_pDevice, m_pDevice); + W32_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W32_PTR(VkInstance_T *m_pInstance, m_pInstance); + W32_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_44[4]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VRVulkanTextureData_t w_VRVulkanTextureData_t; +typedef u32_VRVulkanTextureData_t u_VRVulkanTextureData_t; +#endif +#ifdef __x86_64__ +typedef w64_VRVulkanTextureData_t w_VRVulkanTextureData_t; +typedef u64_VRVulkanTextureData_t u_VRVulkanTextureData_t; +#endif + +#pragma pack( push, 8 ) +struct w64_VulkanData_t +{ + uint64_t m_nImage; + W64_PTR(VkDevice_T *m_pDevice, m_pDevice); + W64_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W64_PTR(VkInstance_T *m_pInstance, m_pInstance); + W64_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_60[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_VulkanData_t +{ + uint64_t m_nImage; + W32_PTR(VkDevice_T *m_pDevice, m_pDevice); + W32_PTR(VkPhysicalDevice_T *m_pPhysicalDevice, m_pPhysicalDevice); + W32_PTR(VkInstance_T *m_pInstance, m_pInstance); + W32_PTR(VkQueue_T *m_pQueue, m_pQueue); + uint32_t m_nQueueFamilyIndex; + uint32_t m_nWidth; + uint32_t m_nHeight; + uint32_t m_nFormat; + uint32_t m_nSampleCount; + uint8_t __pad_44[4]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_VulkanData_t w_VulkanData_t; +typedef u32_VulkanData_t u_VulkanData_t; +#endif +#ifdef __x86_64__ +typedef w64_VulkanData_t w_VulkanData_t; +typedef u64_VulkanData_t u_VulkanData_t; +#endif +