suyu/Yucom
25
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

vrclient: Simplify unix side parameter conversions.

Browse source 
CW-Bug-Id: #22729
This commit is contained in:
Rémi Bernon 2023-09-27 14:09:21 +02:00
parent 4852a1bfdd
commit 8d07121950
55 changed files with 630 additions and 634 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
vrclient_x64/gen_wrapper.py
View file

@ -302,6 +302,12 @@ def underlying_type(decl):
return decl return decl
def param_needs_conversion(decl):
decl = underlying_type(decl)
return decl.kind == TypeKind.RECORD and \
struct_needs_conversion(decl)
def declspec(decl, name): def declspec(decl, name):
if type(decl) is Cursor: if type(decl) is Cursor:
decl = decl.type decl = decl.type
@ -357,6 +363,9 @@ def handle_method_cpp(method, classname, cppname, out):
for i, p in enumerate(method.get_arguments())] for i, p in enumerate(method.get_arguments())]
params = [declspec(p, names[i]) for i, p in enumerate(method.get_arguments())] params = [declspec(p, names[i]) for i, p in enumerate(method.get_arguments())]
need_convert = {n: p for n, p in zip(names, method.get_arguments())
if param_needs_conversion(p)}
names = ['linux_side'] + names names = ['linux_side'] + names
params = ['void *linux_side'] + params params = ['void *linux_side'] + params
@ -366,49 +375,36 @@ def handle_method_cpp(method, classname, cppname, out):
if not returns_void: if not returns_void:
out(f' {declspec(method.result_type, "_ret")};\n') out(f' {declspec(method.result_type, "_ret")};\n')
do_lin_to_win = None need_unwrap = {}
do_win_to_lin = None need_output = {}
do_wrap = None
do_unwrap = None for name, param in sorted(need_convert.items()):
for param in method.get_arguments(): type_name = strip_ns(underlying_typename(param))
if param.type.kind == TypeKind.POINTER and \
param.type.get_pointee().kind == TypeKind.UNEXPOSED: if param.type.kind != TypeKind.POINTER:
#unspecified function pointer out(f' {type_name} lin_{name};\n')
out(f' win_to_lin_struct_{param.type.spelling}_{display_sdkver(sdkver)}(&{name}, &lin_{name});\n')
continue continue
real_type = param.type; pointee = param.type.get_pointee()
while real_type.kind == TypeKind.POINTER: if pointee.kind == TypeKind.POINTER:
real_type = real_type.get_pointee() need_output[name] = param
if param.type.kind == TypeKind.POINTER: out(f' {type_name} *lin_{name};\n')
if strip_ns(param.type.get_pointee().get_canonical().spelling) in SDK_STRUCTS: continue
do_unwrap = (strip_ns(param.type.get_pointee().get_canonical().spelling), param.spelling)
elif param.type.get_pointee().get_canonical().kind == TypeKind.POINTER and \
strip_ns(param.type.get_pointee().get_pointee().get_canonical().spelling) in SDK_STRUCTS:
do_wrap = (strip_ns(param.type.get_pointee().get_pointee().get_canonical().spelling), param.spelling)
elif real_type.get_canonical().kind == TypeKind.RECORD and \
struct_needs_conversion(real_type.get_canonical()):
real_name = canonical_typename(real_type)
do_win_to_lin = (strip_ns(real_name), param.spelling)
if not real_type.is_const_qualified():
do_lin_to_win = (strip_ns(real_name), param.spelling)
if do_lin_to_win or do_win_to_lin: if type_name in SDK_STRUCTS:
if do_lin_to_win: need_unwrap[name] = param
out(f' {do_lin_to_win[0]} lin;\n') continue
else:
out(f' {do_win_to_lin[0]} lin;\n')
if do_wrap: if not pointee.is_const_qualified():
out(f' {do_wrap[0]} *lin;\n') need_output[name] = param
if do_win_to_lin:
#XXX we should pass the struct size here
out(f' if ({do_win_to_lin[1]})\n')
out(f' struct_{strip_ns(do_win_to_lin[0])}_{display_sdkver(sdkver)}_win_to_lin({do_win_to_lin[1]}, &lin);\n')
out(f' {type_name} lin_{name};\n')
out(f' if ({name})\n')
out(f' struct_{type_name}_{display_sdkver(sdkver)}_win_to_lin({name}, &lin_{name});\n')
size_fixup = {} size_fixup = {}
convert_size_param = "" size_param = {}
params = list(zip(names[1:], method.get_arguments())) params = list(zip(names[1:], method.get_arguments()))
params += [(None, None)] # for next_name, next_param params += [(None, None)] # for next_name, next_param
for i, (name, param) in enumerate(params[:-1]): for i, (name, param) in enumerate(params[:-1]):
@ -418,16 +414,16 @@ def handle_method_cpp(method, classname, cppname, out):
next_name, next_param = params[i + 1] next_name, next_param = params[i + 1]
if not next_param or next_param.type.spelling != "uint32_t": if not next_param or next_param.type.spelling != "uint32_t":
convert_size_param = ', -1' size_param[name] = ', -1'
elif struct_needs_size_adjustment(real_type.get_canonical()): elif struct_needs_size_adjustment(real_type.get_canonical()):
real_name = real_type.spelling real_name = real_type.spelling
out(f' uint32_t lin_{next_name} = std::min({next_name}, (uint32_t)sizeof({real_name}));\n') out(f' uint32_t lin_{next_name} = std::min({next_name}, (uint32_t)sizeof({real_name}));\n')
convert_size_param = f', {next_name}' size_param[name] = f', {next_name}'
size_fixup[next_name] = True size_fixup[next_name] = True
elif do_win_to_lin and do_win_to_lin[1] == name: elif name in need_convert:
assert do_win_to_lin[0] not in STRUCTS_NEXT_IS_SIZE_UNHANDLED assert name not in STRUCTS_NEXT_IS_SIZE_UNHANDLED
out(f' uint32_t lin_{next_name} = {next_name} ? sizeof(lin) : 0;\n') out(f' uint32_t lin_{next_name} = {next_name} ? sizeof(lin_{name}) : 0;\n')
convert_size_param = f', {next_name}' size_param[name] = f', {next_name}'
size_fixup[next_name] = True size_fixup[next_name] = True
if returns_void: if returns_void:
@ -435,29 +431,25 @@ def handle_method_cpp(method, classname, cppname, out):
else: else:
out(u' _ret = ') out(u' _ret = ')
params = [] def param_call(name, param):
for name, param in zip(names[1:], method.get_arguments()): pfx = '&' if param.type.kind == TypeKind.POINTER else ''
if name in size_fixup: if name in size_fixup: return f'lin_{name}'
params.append(f'lin_{name}') if name in need_unwrap: return f'struct_{type_name}_{display_sdkver(sdkver)}_unwrap({name})'
elif do_lin_to_win and do_lin_to_win[1] == name or \ if name in need_convert: return f"{name} ? {pfx}lin_{name} : nullptr"
do_win_to_lin and do_win_to_lin[1] == name or \ if param.type.kind == TypeKind.LVALUEREFERENCE: return f'*{name}'
do_wrap and do_wrap[1] == name: return f"({param.type.spelling}){name}"
params.append("%s ? &lin : nullptr" % name)
elif do_unwrap and do_unwrap[1] == name:
params.append("struct_%s_%s_unwrap(%s)" % (strip_ns(do_unwrap[0]), display_sdkver(sdkver), do_unwrap[1]))
elif "&" in param.type.spelling:
params.append("*%s" % name)
else:
params.append("(%s)%s" % (param.type.spelling, name))
params = [param_call(n, p) for n, p in zip(names[1:], method.get_arguments())]
out(f'(({classname}*)linux_side)->{method.spelling}({", ".join(params)});\n') out(f'(({classname}*)linux_side)->{method.spelling}({", ".join(params)});\n')
if do_lin_to_win: for name, param in sorted(need_output.items()):
out(f' if ({do_lin_to_win[1]})\n') type_name = strip_ns(underlying_typename(param))
out(f' struct_{strip_ns(do_lin_to_win[0])}_{display_sdkver(sdkver)}_lin_to_win(&lin, {do_lin_to_win[1]}{convert_size_param});\n') if type_name in SDK_STRUCTS:
if do_wrap and not returns_void:
out(u' if (_ret == 0)\n') out(u' if (_ret == 0)\n')
out(f' *{do_wrap[1]} = struct_{strip_ns(do_wrap[0])}_{display_sdkver(sdkver)}_wrap(lin);\n') out(f' *{name} = struct_{type_name}_{display_sdkver(sdkver)}_wrap(lin_{name});\n')
continue
out(f' if ({name})\n')
out(f' struct_{type_name}_{display_sdkver(sdkver)}_lin_to_win(&lin_{name}, {name}{size_param.get(name, "")});\n')
if not returns_void: if not returns_void:
out(u' return _ret;\n') out(u' return _ret;\n')
@ -706,6 +698,10 @@ def canonical_typename(cursor):
return name.removeprefix("const ") return name.removeprefix("const ")
def underlying_typename(decl):
return canonical_typename(underlying_type(decl))
def find_struct_abis(name): def find_struct_abis(name):
records = all_records[sdkver] records = all_records[sdkver]
missing = [name not in records[abi] for abi in ABIS] missing = [name not in records[abi] for abi in ABIS]

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.cpp
View file

@ -88,12 +88,12 @@ void cppIVRCompositor_IVRCompositor_005_ClearOverlay(void *linux_side)
bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_091 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_091 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_091_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_091_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_091_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_091_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.cpp
View file

@ -67,12 +67,12 @@ void cppIVRCompositor_IVRCompositor_006_ClearLastSubmittedFrame(void *linux_side
bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_092 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_092 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_092_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_092_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_092_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_092_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.cpp
View file

@ -62,12 +62,12 @@ void cppIVRCompositor_IVRCompositor_007_ClearLastSubmittedFrame(void *linux_side
bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_098 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_098 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_098_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_098_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_098_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_098_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.cpp
View file

@ -62,12 +62,12 @@ void cppIVRCompositor_IVRCompositor_008_ClearLastSubmittedFrame(void *linux_side
bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0910 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0910 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0910_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_0910_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0910_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_0910_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.cpp
View file

@ -55,12 +55,12 @@ void cppIVRCompositor_IVRCompositor_009_PostPresentHandoff(void *linux_side)
bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0913 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0913 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0913_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_0913_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0913_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_0913_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.cpp
View file

@ -55,12 +55,12 @@ void cppIVRCompositor_IVRCompositor_010_PostPresentHandoff(void *linux_side)
bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0914 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0914 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0914_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_0914_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_0914_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_0914_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

8
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.cpp
View file

@ -62,12 +62,12 @@ void cppIVRCompositor_IVRCompositor_016_PostPresentHandoff(void *linux_side)
bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_103 *pTiming, uint32_t unFramesAgo) bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_103 *pTiming, uint32_t unFramesAgo)
{ {
bool _ret; bool _ret;
Compositor_FrameTiming lin; Compositor_FrameTiming lin_pTiming;
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_103_win_to_lin(pTiming, &lin); struct_Compositor_FrameTiming_103_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo); _ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming) if (pTiming)
struct_Compositor_FrameTiming_103_lin_to_win(&lin, pTiming); struct_Compositor_FrameTiming_103_lin_to_win(&lin_pTiming, pTiming);
return _ret; return _ret;
} }

38
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.cpp
View file

@ -47,51 +47,51 @@ EVRInputError cppIVRInput_IVRInput_003_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1015 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1015 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1015_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1015_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1015_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1015 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1015 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1015_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1015_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1015_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1015 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1015 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1015_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1015_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1015_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, winInputSkeletonActionData_t_1015 *pActionData, uint32_t unActionDataSize, VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount) EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, winInputSkeletonActionData_t_1015 *pActionData, uint32_t unActionDataSize, VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletonActionData_t lin; InputSkeletonActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletonActionData_t_1015_win_to_lin(pActionData, &lin); struct_InputSkeletonActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eBoneParent, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, (uint32_t)unActionDataSize, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eBoneParent, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, (uint32_t)unActionDataSize, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
if (pActionData) if (pActionData)
struct_InputSkeletonActionData_t_1015_lin_to_win(&lin, pActionData); struct_InputSkeletonActionData_t_1015_lin_to_win(&lin_pActionData, pActionData);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp
View file

@ -47,52 +47,52 @@ EVRInputError cppIVRInput_IVRInput_004_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1017_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1017_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1017_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1017_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1017_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1017_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1017_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1017_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1017_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletalActionData_t lin; InputSkeletalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1017_win_to_lin(pActionData, &lin); struct_InputSkeletalActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1017_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputSkeletalActionData_t_1017_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp
View file

@ -47,52 +47,52 @@ EVRInputError cppIVRInput_IVRInput_005_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1322_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1322_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1322_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1322_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1322_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1322_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1322_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1322_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1322_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1322 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1322 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletalActionData_t lin; InputSkeletalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1322_win_to_lin(pActionData, &lin); struct_InputSkeletalActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1322_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputSkeletalActionData_t_1322_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }

50
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp
View file

@ -47,65 +47,65 @@ EVRInputError cppIVRInput_IVRInput_006_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1418_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1418_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1418_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1418_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1418_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1418_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1418_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1418_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1418_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1418_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1418 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1418 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletalActionData_t lin; InputSkeletalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1418_win_to_lin(pActionData, &lin); struct_InputSkeletalActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1418_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputSkeletalActionData_t_1418_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }

50
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
View file

@ -47,65 +47,65 @@ EVRInputError cppIVRInput_IVRInput_007_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1916_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1916_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1916_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1916_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1916_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1916_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1916_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1916_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1916_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1916_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1916 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1916 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletalActionData_t lin; InputSkeletalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1916_win_to_lin(pActionData, &lin); struct_InputSkeletalActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1916_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputSkeletalActionData_t_1916_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }

50
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp
View file

@ -47,65 +47,65 @@ EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *linux_side, VRAct
EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputDigitalActionData_t lin; InputDigitalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin); struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputDigitalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputDigitalActionData_t_1267_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputAnalogActionData_t lin; InputAnalogActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin); struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputAnalogActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputAnalogActionData_t_1267_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1267_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{ {
EVRInputError _ret; EVRInputError _ret;
InputPoseActionData_t lin; InputPoseActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin); struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice); _ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if (pActionData) if (pActionData)
struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputPoseActionData_t_1267_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }
EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1267 *pActionData, uint32_t unActionDataSize) EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1267 *pActionData, uint32_t unActionDataSize)
{ {
EVRInputError _ret; EVRInputError _ret;
InputSkeletalActionData_t lin; InputSkeletalActionData_t lin_pActionData;
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin); struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0; uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize); _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
if (pActionData) if (pActionData)
struct_InputSkeletalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize); struct_InputSkeletalActionData_t_1267_lin_to_win(&lin_pActionData, pActionData, unActionDataSize);
return _ret; return _ret;
} }

6
vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp
View file

@ -25,10 +25,10 @@ EVROverlayError cppIVROverlayView_IVROverlayView_003_ReleaseOverlayView(void *li
void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent) void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent)
{ {
VREvent_t lin; VREvent_t lin_pvrEvent;
if (pvrEvent) if (pvrEvent)
struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin); struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin_pvrEvent);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr); ((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin_pvrEvent : nullptr);
} }
bool cppIVROverlayView_IVROverlayView_003_IsViewingPermitted(void *linux_side, VROverlayHandle_t ulOverlayHandle) bool cppIVROverlayView_IVROverlayView_003_IsViewingPermitted(void *linux_side, VROverlayHandle_t ulOverlayHandle)

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_010.cpp
View file

@ -250,13 +250,13 @@ EVROverlayError cppIVROverlay_IVROverlay_010_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_010_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_010_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin); struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_0918_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_0918_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_011.cpp
View file

@ -264,13 +264,13 @@ EVROverlayError cppIVROverlay_IVROverlay_011_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_011_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_0920 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_011_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_0920 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_0920_win_to_lin(pEvent, &lin); struct_VREvent_t_0920_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_0920_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_0920_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_012.cpp
View file

@ -264,13 +264,13 @@ EVROverlayError cppIVROverlay_IVROverlay_012_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_012_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_101 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_012_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_101 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_101_win_to_lin(pEvent, &lin); struct_VREvent_t_101_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_101_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_101_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_013.cpp
View file

@ -292,13 +292,13 @@ EVROverlayError cppIVROverlay_IVROverlay_013_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_013_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_104 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_013_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_104 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin); struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_104_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_104_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_014.cpp
View file

@ -292,13 +292,13 @@ EVROverlayError cppIVROverlay_IVROverlay_014_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_014_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_106 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_014_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_106 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_106_win_to_lin(pEvent, &lin); struct_VREvent_t_106_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_106_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_106_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_016.cpp
View file

@ -327,13 +327,13 @@ EVROverlayError cppIVROverlay_IVROverlay_016_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_016_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1010 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_016_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1010 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1010_win_to_lin(pEvent, &lin); struct_VREvent_t_1010_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1010_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1010_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_017.cpp
View file

@ -327,13 +327,13 @@ EVROverlayError cppIVROverlay_IVROverlay_017_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_017_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_017_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin); struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1011_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1011_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_018.cpp
View file

@ -327,13 +327,13 @@ EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1017 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1017 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1017_win_to_lin(pEvent, &lin); struct_VREvent_t_1017_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1017_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1017_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_019.cpp
View file

@ -327,13 +327,13 @@ EVROverlayError cppIVROverlay_IVROverlay_019_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1610 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1610 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1610_win_to_lin(pEvent, &lin); struct_VREvent_t_1610_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1610_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1610_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_020.cpp
View file

@ -313,13 +313,13 @@ EVROverlayError cppIVROverlay_IVROverlay_020_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_020_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_020_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin); struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1715_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1715_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.cpp
View file

@ -313,13 +313,13 @@ EVROverlayError cppIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_021_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1819 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_021_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1819 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1819_win_to_lin(pEvent, &lin); struct_VREvent_t_1819_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1819_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1819_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_022.cpp
View file

@ -334,13 +334,13 @@ EVROverlayError cppIVROverlay_IVROverlay_022_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_022_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1916 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_022_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1916 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1916_win_to_lin(pEvent, &lin); struct_VREvent_t_1916_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1916_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1916_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_024.cpp
View file

@ -320,13 +320,13 @@ EVROverlayError cppIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_024_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_11415 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_024_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_11415 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_11415_win_to_lin(pEvent, &lin); struct_VREvent_t_11415_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_11415_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_11415_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.cpp
View file

@ -327,13 +327,13 @@ EVROverlayError cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(v
bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1168_win_to_lin(pEvent, &lin); struct_VREvent_t_1168_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1168_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1168_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_026.cpp
View file

@ -348,13 +348,13 @@ EVROverlayError cppIVROverlay_IVROverlay_026_WaitFrameSync(void *linux_side, uin
bool cppIVROverlay_IVROverlay_026_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1237 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_026_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1237 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1237_win_to_lin(pEvent, &lin); struct_VREvent_t_1237_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1237_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

10
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_027.cpp
View file

@ -334,13 +334,13 @@ EVROverlayError cppIVROverlay_IVROverlay_027_WaitFrameSync(void *linux_side, uin
bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent) bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin); struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1267_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }

18
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_002.cpp
View file

@ -12,10 +12,10 @@ extern "C" {
bool cppIVRRenderModels_IVRRenderModels_002_LoadRenderModel(void *linux_side, const char *pchRenderModelName, winRenderModel_t_0915 **ppRenderModel) bool cppIVRRenderModels_IVRRenderModels_002_LoadRenderModel(void *linux_side, const char *pchRenderModelName, winRenderModel_t_0915 **ppRenderModel)
{ {
bool _ret; bool _ret;
RenderModel_t *lin; RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0) if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_0915_wrap(lin); *ppRenderModel = struct_RenderModel_t_0915_wrap(lin_ppRenderModel);
return _ret; return _ret;
} }
@ -27,10 +27,10 @@ void cppIVRRenderModels_IVRRenderModels_002_FreeRenderModel(void *linux_side, wi
bool cppIVRRenderModels_IVRRenderModels_002_LoadTexture(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_0915 **ppTexture) bool cppIVRRenderModels_IVRRenderModels_002_LoadTexture(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_0915 **ppTexture)
{ {
bool _ret; bool _ret;
RenderModel_TextureMap_t *lin; RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadTexture((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0) if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_0915_wrap(lin); *ppTexture = struct_RenderModel_TextureMap_t_0915_wrap(lin_ppTexture);
return _ret; return _ret;
} }
@ -84,10 +84,10 @@ uint32_t cppIVRRenderModels_IVRRenderModels_002_GetComponentRenderModelName(void
bool cppIVRRenderModels_IVRRenderModels_002_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, RenderModel_ComponentState_t *pComponentState) bool cppIVRRenderModels_IVRRenderModels_002_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, RenderModel_ComponentState_t *pComponentState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0915_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0915_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (vr::RenderModel_ComponentState_t *)pComponentState); _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin_pControllerState : nullptr, (vr::RenderModel_ComponentState_t *)pComponentState);
return _ret; return _ret;
} }

18
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_004.cpp
View file

@ -12,10 +12,10 @@ extern "C" {
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_004_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_0918 **ppRenderModel) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_004_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_0918 **ppRenderModel)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_t *lin; RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0) if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_0918_wrap(lin); *ppRenderModel = struct_RenderModel_t_0918_wrap(lin_ppRenderModel);
return _ret; return _ret;
} }
@ -27,10 +27,10 @@ void cppIVRRenderModels_IVRRenderModels_004_FreeRenderModel(void *linux_side, wi
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_0918 **ppTexture) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_0918 **ppTexture)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_TextureMap_t *lin; RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0) if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_0918_wrap(lin); *ppTexture = struct_RenderModel_TextureMap_t_0918_wrap(lin_ppTexture);
return _ret; return _ret;
} }
@ -96,10 +96,10 @@ uint32_t cppIVRRenderModels_IVRRenderModels_004_GetComponentRenderModelName(void
bool cppIVRRenderModels_IVRRenderModels_004_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) bool cppIVRRenderModels_IVRRenderModels_004_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState); _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin_pControllerState : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
return _ret; return _ret;
} }

18
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp
View file

@ -12,10 +12,10 @@ extern "C" {
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_1015 **ppRenderModel) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_1015 **ppRenderModel)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_t *lin; RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0) if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_1015_wrap(lin); *ppRenderModel = struct_RenderModel_t_1015_wrap(lin_ppRenderModel);
return _ret; return _ret;
} }
@ -27,10 +27,10 @@ void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *linux_side, wi
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1015 **ppTexture) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1015 **ppTexture)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_TextureMap_t *lin; RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0) if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_1015_wrap(lin); *ppTexture = struct_RenderModel_TextureMap_t_1015_wrap(lin_ppTexture);
return _ret; return _ret;
} }
@ -103,10 +103,10 @@ uint32_t cppIVRRenderModels_IVRRenderModels_005_GetComponentRenderModelName(void
bool cppIVRRenderModels_IVRRenderModels_005_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) bool cppIVRRenderModels_IVRRenderModels_005_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1015_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1015_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState); _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin_pControllerState : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
return _ret; return _ret;
} }

18
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
View file

@ -12,10 +12,10 @@ extern "C" {
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_1267 **ppRenderModel) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char *pchRenderModelName, winRenderModel_t_1267 **ppRenderModel)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_t *lin; RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0) if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_1267_wrap(lin); *ppRenderModel = struct_RenderModel_t_1267_wrap(lin_ppRenderModel);
return _ret; return _ret;
} }
@ -27,10 +27,10 @@ void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, wi
EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1267 **ppTexture) EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1267 **ppTexture)
{ {
EVRRenderModelError _ret; EVRRenderModelError _ret;
RenderModel_TextureMap_t *lin; RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr); _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0) if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin); *ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin_ppTexture);
return _ret; return _ret;
} }
@ -110,10 +110,10 @@ bool cppIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(void
bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState) bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side, const char *pchRenderModelName, const char *pchComponentName, const VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState); _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin_pControllerState : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_003.cpp
View file

@ -199,24 +199,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_003_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_003_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_091 *pControllerState) bool cppIVRSystem_IVRSystem_003_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_091 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_091_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_091_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_003_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_091 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_003_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_091 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_091_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_091_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_004.cpp
View file

@ -187,24 +187,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_004_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_004_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_092 *pControllerState) bool cppIVRSystem_IVRSystem_004_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_092 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_092_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_092_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_004_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_092 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_004_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_092 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_092_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_092_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_005.cpp
View file

@ -194,24 +194,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_005_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_005_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_098 *pControllerState) bool cppIVRSystem_IVRSystem_005_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_098 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_098_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_098_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_005_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_098 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_005_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_098 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_098_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_098_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_006.cpp
View file

@ -208,24 +208,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_006_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_006_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0910 *pControllerState) bool cppIVRSystem_IVRSystem_006_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0910 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0910_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0910_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_006_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0910 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_006_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0910 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0910_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0910_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_009.cpp
View file

@ -210,24 +210,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_009_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_009_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0912 *pControllerState) bool cppIVRSystem_IVRSystem_009_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0912 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0912_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0912_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_009_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0912 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_009_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0912 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0912_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0912_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

16
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_010.cpp
View file

@ -224,24 +224,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_010_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_010_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0914 *pControllerState) bool cppIVRSystem_IVRSystem_010_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0914 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0914_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0914_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_010_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0914 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_010_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0914 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0914_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0914_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

36
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_011.cpp
View file

@ -196,26 +196,26 @@ const char * cppIVRSystem_IVRSystem_011_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_011_PollNextEvent(void *linux_side, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_011_PollNextEvent(void *linux_side, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin); struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_0918_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_0918_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_011_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_011_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin); struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_0918_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_0918_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -236,24 +236,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_011_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_011_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0918 *pControllerState) bool cppIVRSystem_IVRSystem_011_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0918 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0918_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0918_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_011_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0918 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_011_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0918 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_0918_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_0918_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

36
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_012.cpp
View file

@ -196,26 +196,26 @@ const char * cppIVRSystem_IVRSystem_012_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_012_PollNextEvent(void *linux_side, winVREvent_t_103 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_012_PollNextEvent(void *linux_side, winVREvent_t_103 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_103_win_to_lin(pEvent, &lin); struct_VREvent_t_103_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_103_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_103_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_012_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_012_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_103_win_to_lin(pEvent, &lin); struct_VREvent_t_103_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_103_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_103_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -236,24 +236,24 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_012_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_012_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_103 *pControllerState) bool cppIVRSystem_IVRSystem_012_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_103 *pControllerState)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_103_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_103_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_012_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_103 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_012_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_103 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_103_lin_to_win(&lin, pControllerState, -1); struct_VRControllerState001_t_103_lin_to_win(&lin_pControllerState, pControllerState, -1);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_014.cpp
View file

@ -196,26 +196,26 @@ const char * cppIVRSystem_IVRSystem_014_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_014_PollNextEvent(void *linux_side, winVREvent_t_104 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_014_PollNextEvent(void *linux_side, winVREvent_t_104 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin); struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_104_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_104_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_014_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_104 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_014_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_104 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin); struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_104_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_104_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -236,26 +236,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_014_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_014_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_104 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_014_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_104 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_104_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_104_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_014_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_104 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_014_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_104 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_104_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_104_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_015.cpp
View file

@ -196,26 +196,26 @@ const char * cppIVRSystem_IVRSystem_015_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_015_PollNextEvent(void *linux_side, winVREvent_t_107 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_015_PollNextEvent(void *linux_side, winVREvent_t_107 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_107_win_to_lin(pEvent, &lin); struct_VREvent_t_107_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_107_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_107_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_015_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_107 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_015_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_107 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_107_win_to_lin(pEvent, &lin); struct_VREvent_t_107_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_107_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_107_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -236,26 +236,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_015_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_015_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_107 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_015_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_107 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_107_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_107_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_015_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_107 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_015_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_107 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_107_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_107_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_016.cpp
View file

@ -201,26 +201,26 @@ const char * cppIVRSystem_IVRSystem_016_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_016_PollNextEvent(void *linux_side, winVREvent_t_109 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_016_PollNextEvent(void *linux_side, winVREvent_t_109 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_109_win_to_lin(pEvent, &lin); struct_VREvent_t_109_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_109_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_109_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_016_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_109 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_016_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_109 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_109_win_to_lin(pEvent, &lin); struct_VREvent_t_109_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_109_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_109_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -241,26 +241,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_016_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_016_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_109 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_016_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_109 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_109_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_109_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_016_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_109 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_016_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_109 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_109_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_109_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_017.cpp
View file

@ -201,26 +201,26 @@ const char * cppIVRSystem_IVRSystem_017_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_017_PollNextEvent(void *linux_side, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_017_PollNextEvent(void *linux_side, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin); struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1011_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1011_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_017_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_017_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin); struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_1011_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1011_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -241,26 +241,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_017_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_017_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1011 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_017_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1011 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1011_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1011_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_017_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1011 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_017_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1011 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1011_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1011_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_019.cpp
View file

@ -208,26 +208,26 @@ const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1418 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1418 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1418_win_to_lin(pEvent, &lin); struct_VREvent_t_1418_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1418_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1418_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1418 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1418 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1418_win_to_lin(pEvent, &lin); struct_VREvent_t_1418_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_1418_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1418_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -248,26 +248,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1418_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1418_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1418_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1418_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_020.cpp
View file

@ -208,26 +208,26 @@ const char * cppIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *linux_side, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *linux_side, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin); struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1715_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1715_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin); struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_1715_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1715_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -248,26 +248,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_020_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_020_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1715 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_020_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1715 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1715_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1715_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1715 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1715 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1715_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1715_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.cpp
View file

@ -208,26 +208,26 @@ const char * cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *linux_side, winVREvent_t_1125 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *linux_side, winVREvent_t_1125 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1125_win_to_lin(pEvent, &lin); struct_VREvent_t_1125_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1125_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1125_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1125 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1125 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1125_win_to_lin(pEvent, &lin); struct_VREvent_t_1125_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_1125_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1125_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -248,26 +248,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_021_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1125 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_021_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1125 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1125_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1125_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1125 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1125 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1125_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1125_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

40
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp
View file

@ -203,26 +203,26 @@ const char * cppIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(void *linux_sid
bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent) bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin); struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent); _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
if (pEvent) if (pEvent)
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1267_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VREvent_t lin; VREvent_t lin_pEvent;
if (pEvent) if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin); struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0; uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pEvent) if (pEvent)
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent); struct_VREvent_t_1267_lin_to_win(&lin_pEvent, pEvent, uncbVREvent);
return _ret; return _ret;
} }
@ -243,26 +243,26 @@ HiddenAreaMesh_t cppIVRSystem_IVRSystem_022_GetHiddenAreaMesh(void *linux_side,
bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 *pControllerState, uint32_t unControllerStateSize) bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 *pControllerState, uint32_t unControllerStateSize)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize); _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1267_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
bool _ret; bool _ret;
VRControllerState001_t lin; VRControllerState001_t lin_pControllerState;
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin); struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0; uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose); _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if (pControllerState) if (pControllerState)
struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize); struct_VRControllerState001_t_1267_lin_to_win(&lin_pControllerState, pControllerState, unControllerStateSize);
return _ret; return _ret;
} }

6
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_001.cpp
View file

@ -89,10 +89,10 @@ const CameraVideoStreamFrame_t * cppIVRTrackedCamera_IVRTrackedCamera_001_GetVid
bool cppIVRTrackedCamera_IVRTrackedCamera_001_ReleaseVideoStreamFrame(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, const CameraVideoStreamFrame_t *pFrameImage) bool cppIVRTrackedCamera_IVRTrackedCamera_001_ReleaseVideoStreamFrame(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, const CameraVideoStreamFrame_t *pFrameImage)
{ {
bool _ret; bool _ret;
CameraVideoStreamFrame_t lin; CameraVideoStreamFrame_t lin_pFrameImage;
if (pFrameImage) if (pFrameImage)
struct_CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin); struct_CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin_pFrameImage);
_ret = ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamFrame((vr::TrackedDeviceIndex_t)nDeviceIndex, pFrameImage ? &lin : nullptr); _ret = ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamFrame((vr::TrackedDeviceIndex_t)nDeviceIndex, pFrameImage ? &lin_pFrameImage : nullptr);
return _ret; return _ret;
} }

30
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp
View file

@ -61,13 +61,13 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStrea
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
@ -81,26 +81,26 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTex
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1017_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }

30
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp
View file

@ -61,13 +61,13 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_ReleaseVideoStrea
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
@ -81,26 +81,26 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTex
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1610 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1610_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }

30
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
View file

@ -61,13 +61,13 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStrea
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
@ -81,26 +81,26 @@ EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTex
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }
EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize) EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t *pglTextureId, winCameraVideoStreamFrameHeader_t_1267 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
EVRTrackedCameraError _ret; EVRTrackedCameraError _ret;
CameraVideoStreamFrameHeader_t lin; CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin); struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0; uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin_pFrameHeader) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize); _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin_pFrameHeader : nullptr, lin_nFrameHeaderSize);
if (pFrameHeader) if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize); struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin_pFrameHeader, pFrameHeader, nFrameHeaderSize);
return _ret; return _ret;
} }