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

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 committed by Arkadiusz Hiler
parent d8038254d4
commit e4d75b2fb0
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
def param_needs_conversion(decl):
decl = underlying_type(decl)
return decl.kind == TypeKind.RECORD and \
struct_needs_conversion(decl)
def declspec(decl, name):
if type(decl) is Cursor:
decl = decl.type
@ -357,6 +363,9 @@ def handle_method_cpp(method, classname, cppname, out):
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
params = ['void *linux_side'] + params
@ -366,49 +375,36 @@ def handle_method_cpp(method, classname, cppname, out):
if not returns_void:
out(f' {declspec(method.result_type, "_ret")};\n')
do_lin_to_win = None
do_win_to_lin = None
do_wrap = None
do_unwrap = None
for param in method.get_arguments():
if param.type.kind == TypeKind.POINTER and \
param.type.get_pointee().kind == TypeKind.UNEXPOSED:
#unspecified function pointer
need_unwrap = {}
need_output = {}
for name, param in sorted(need_convert.items()):
type_name = strip_ns(underlying_typename(param))
if param.type.kind != TypeKind.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
real_type = param.type;
while real_type.kind == TypeKind.POINTER:
real_type = real_type.get_pointee()
if param.type.kind == TypeKind.POINTER:
if strip_ns(param.type.get_pointee().get_canonical().spelling) in SDK_STRUCTS:
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)
pointee = param.type.get_pointee()
if pointee.kind == TypeKind.POINTER:
need_output[name] = param
out(f' {type_name} *lin_{name};\n')
continue
if do_lin_to_win or do_win_to_lin:
if do_lin_to_win:
out(f' {do_lin_to_win[0]} lin;\n')
else:
out(f' {do_win_to_lin[0]} lin;\n')
if type_name in SDK_STRUCTS:
need_unwrap[name] = param
continue
if do_wrap:
out(f' {do_wrap[0]} *lin;\n')
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')
if not pointee.is_const_qualified():
need_output[name] = param
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 = {}
convert_size_param = ""
size_param = {}
params = list(zip(names[1:], method.get_arguments()))
params += [(None, None)] # for next_name, next_param
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]
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()):
real_name = real_type.spelling
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
elif do_win_to_lin and do_win_to_lin[1] == name:
assert do_win_to_lin[0] not in STRUCTS_NEXT_IS_SIZE_UNHANDLED
out(f' uint32_t lin_{next_name} = {next_name} ? sizeof(lin) : 0;\n')
convert_size_param = f', {next_name}'
elif name in need_convert:
assert name not in STRUCTS_NEXT_IS_SIZE_UNHANDLED
out(f' uint32_t lin_{next_name} = {next_name} ? sizeof(lin_{name}) : 0;\n')
size_param[name] = f', {next_name}'
size_fixup[next_name] = True
if returns_void:
@ -435,29 +431,25 @@ def handle_method_cpp(method, classname, cppname, out):
else:
out(u' _ret = ')
params = []
for name, param in zip(names[1:], method.get_arguments()):
if name in size_fixup:
params.append(f'lin_{name}')
elif do_lin_to_win and do_lin_to_win[1] == name or \
do_win_to_lin and do_win_to_lin[1] == name or \
do_wrap and do_wrap[1] == 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))
def param_call(name, param):
pfx = '&' if param.type.kind == TypeKind.POINTER else ''
if name in size_fixup: return f'lin_{name}'
if name in need_unwrap: return f'struct_{type_name}_{display_sdkver(sdkver)}_unwrap({name})'
if name in need_convert: return f"{name} ? {pfx}lin_{name} : nullptr"
if param.type.kind == TypeKind.LVALUEREFERENCE: return f'*{name}'
return f"({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')
if do_lin_to_win:
out(f' if ({do_lin_to_win[1]})\n')
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 do_wrap and not returns_void:
for name, param in sorted(need_output.items()):
type_name = strip_ns(underlying_typename(param))
if type_name in SDK_STRUCTS:
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:
out(u' return _ret;\n')
@ -706,6 +698,10 @@ def canonical_typename(cursor):
return name.removeprefix("const ")
def underlying_typename(decl):
return canonical_typename(underlying_type(decl))
def find_struct_abis(name):
records = all_records[sdkver]
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_091_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_091_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_091_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_091_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_092_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_092_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_092_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_092_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_098_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_098_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_098_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_098_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_0910_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_0910_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_0910_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_0910_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_0913_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_0913_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_0913_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_0913_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_0914_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_0914_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_0914_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_0914_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
Compositor_FrameTiming lin;
Compositor_FrameTiming lin_pTiming;
if (pTiming)
struct_Compositor_FrameTiming_103_win_to_lin(pTiming, &lin);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin : nullptr, (uint32_t)unFramesAgo);
struct_Compositor_FrameTiming_103_win_to_lin(pTiming, &lin_pTiming);
_ret = ((IVRCompositor*)linux_side)->GetFrameTiming(pTiming ? &lin_pTiming : nullptr, (uint32_t)unFramesAgo);
if (pTiming)
struct_Compositor_FrameTiming_103_lin_to_win(&lin, pTiming);
struct_Compositor_FrameTiming_103_lin_to_win(&lin_pTiming, pTiming);
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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1015_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputDigitalActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}
EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1015 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1015_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputAnalogActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}
EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1015 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1015_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputPoseActionData_t_1015_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize);
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;
}
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;
InputSkeletonActionData_t lin;
InputSkeletonActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletonActionData_t_1015_win_to_lin(pActionData, &lin);
_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);
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_pActionData : nullptr, (uint32_t)unActionDataSize, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
if (pActionData)
struct_InputSkeletonActionData_t_1015_lin_to_win(&lin, pActionData);
struct_InputSkeletonActionData_t_1015_lin_to_win(&lin_pActionData, pActionData);
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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1017_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputDigitalActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1017_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputAnalogActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1017_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1017 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputSkeletalActionData_t lin;
InputSkeletalActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletalActionData_t_1017_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputSkeletalActionData_t_1017_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}

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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1322_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputDigitalActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1322 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1322_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputAnalogActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1322_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1322 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputSkeletalActionData_t lin;
InputSkeletalActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletalActionData_t_1322_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputSkeletalActionData_t_1322_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}

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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1418_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputDigitalActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1418 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1418_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputAnalogActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1418 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputSkeletalActionData_t lin;
InputSkeletalActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletalActionData_t_1418_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputSkeletalActionData_t_1418_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}

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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1916_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputDigitalActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1916 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1916_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputAnalogActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1916 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputSkeletalActionData_t lin;
InputSkeletalActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletalActionData_t_1916_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputSkeletalActionData_t_1916_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}

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 _ret;
InputDigitalActionData_t lin;
InputDigitalActionData_t lin_pActionData;
if (pActionData)
struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1267 *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
EVRInputError _ret;
InputAnalogActionData_t lin;
InputAnalogActionData_t lin_pActionData;
if (pActionData)
struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
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_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
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;
InputPoseActionData_t lin;
InputPoseActionData_t lin_pActionData;
if (pActionData)
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
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;
}
EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1267 *pActionData, uint32_t unActionDataSize)
{
EVRInputError _ret;
InputSkeletalActionData_t lin;
InputSkeletalActionData_t lin_pActionData;
if (pActionData)
struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, lin_unActionDataSize);
struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin_pActionData);
uint32_t lin_unActionDataSize = unActionDataSize ? sizeof(lin_pActionData) : 0;
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin_pActionData : nullptr, lin_unActionDataSize);
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;
}

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)
{
VREvent_t lin;
VREvent_t lin_pvrEvent;
if (pvrEvent)
struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin_pvrEvent);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin_pvrEvent : nullptr);
}
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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_0920_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_0920_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_101_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_101_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_106_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_106_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1010_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1010_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1017_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1017_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1610_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1610_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1819_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1819_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1916_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1916_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_11415_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_11415_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1168_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1168_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1237_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}

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 _ret;
RenderModel_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_0915_wrap(lin);
*ppRenderModel = struct_RenderModel_t_0915_wrap(lin_ppRenderModel);
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 _ret;
RenderModel_TextureMap_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_0915_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_0915_wrap(lin_ppTexture);
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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0915_win_to_lin(pControllerState, &lin);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (vr::RenderModel_ComponentState_t *)pComponentState);
struct_VRControllerState001_t_0915_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin_pControllerState : nullptr, (vr::RenderModel_ComponentState_t *)pComponentState);
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 _ret;
RenderModel_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_0918_wrap(lin);
*ppRenderModel = struct_RenderModel_t_0918_wrap(lin_ppRenderModel);
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 _ret;
RenderModel_TextureMap_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_0918_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_0918_wrap(lin_ppTexture);
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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin);
_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);
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_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;
}

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 _ret;
RenderModel_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_1015_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1015_wrap(lin_ppRenderModel);
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 _ret;
RenderModel_TextureMap_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_1015_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1015_wrap(lin_ppTexture);
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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1015_win_to_lin(pControllerState, &lin);
_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);
struct_VRControllerState001_t_1015_win_to_lin(pControllerState, &lin_pControllerState);
_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;
}

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 _ret;
RenderModel_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
RenderModel_t *lin_ppRenderModel;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin_ppRenderModel : nullptr);
if (_ret == 0)
*ppRenderModel = struct_RenderModel_t_1267_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1267_wrap(lin_ppRenderModel);
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 _ret;
RenderModel_TextureMap_t *lin;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
RenderModel_TextureMap_t *lin_ppTexture;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin_ppTexture : nullptr);
if (_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin_ppTexture);
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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
_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);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
_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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_003_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_091 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_091_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_004_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_092 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_092_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_005_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_098 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_098_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_006_GetControllerStateWithPose(void *linux_side, TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0910 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_0910_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::TrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_009_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0912 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_0912_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_010_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0914 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_0914_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_011_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_0918 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_0918_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_0918_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_011_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_0918 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_0918_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_103_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_103_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_012_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_103_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_103_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr);
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr);
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;
}
bool cppIVRSystem_IVRSystem_012_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_103 *pControllerState, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_103_win_to_lin(pControllerState, &lin_pControllerState);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_014_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_104 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_104_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_104_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_104_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_107_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_107_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_015_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_107 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_107_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_107_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_107_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_109_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_109_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_016_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_109 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_109_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_109_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_109_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_017_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1011 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1011_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_1011_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_1011_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1418_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1418_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1418 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1418_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_1418_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_1418_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1715 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1715_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_1715_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_1715_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1125_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1125_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1125 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1125_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_1125_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_1125_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, lin_uncbVREvent);
struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent);
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;
}
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{
bool _ret;
VREvent_t lin;
VREvent_t lin_pEvent;
if (pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VREvent_t_1267_win_to_lin(pEvent, &lin_pEvent);
uint32_t lin_uncbVREvent = uncbVREvent ? sizeof(lin_pEvent) : 0;
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin_pEvent : nullptr, lin_uncbVREvent, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}
@ -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 _ret;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize);
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;
}
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;
VRControllerState001_t lin;
VRControllerState001_t lin_pControllerState;
if (pControllerState)
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin_pControllerState);
uint32_t lin_unControllerStateSize = unControllerStateSize ? sizeof(lin_pControllerState) : 0;
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin_pControllerState : nullptr, lin_unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
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;
}

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 _ret;
CameraVideoStreamFrame_t lin;
CameraVideoStreamFrame_t lin_pFrameImage;
if (pFrameImage)
struct_CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin);
_ret = ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamFrame((vr::TrackedDeviceIndex_t)nDeviceIndex, pFrameImage ? &lin : nullptr);
struct_CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin_pFrameImage);
_ret = ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamFrame((vr::TrackedDeviceIndex_t)nDeviceIndex, pFrameImage ? &lin_pFrameImage : nullptr);
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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
@ -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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
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;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1017_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}

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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
@ -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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
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;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1610_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}

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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
@ -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 _ret;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}
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;
CameraVideoStreamFrameHeader_t lin;
CameraVideoStreamFrameHeader_t lin_pFrameHeader;
if (pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
uint32_t lin_nFrameHeaderSize = nFrameHeaderSize ? sizeof(lin) : 0;
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, lin_nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin_pFrameHeader);
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_pFrameHeader : nullptr, lin_nFrameHeaderSize);
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;
}