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

vrclient: Respect provided struct sizes when returning structures.

Browse Source 
CW-Bug-Id: #22729
CW-Bug-Id: #23147
This commit is contained in:
Rémi Bernon 2023-12-15 10:20:25 +01:00 committed by Arkadiusz Hiler
parent 37dc6df5eb
commit 77c5345632
6 changed files with 503 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
vrclient_x64/gen_wrapper.py
View File

@ -158,6 +158,10 @@ STRUCTS_NEXT_IS_SIZE = [
"InputBindingInfo_t", "InputBindingInfo_t",
] ]
STRUCTS_IS_INPUT_ARRAY = [
"VRActiveActionSet_t",
]
STRUCTS_NEXT_IS_SIZE_UNHANDLED = [ STRUCTS_NEXT_IS_SIZE_UNHANDLED = [
"VROverlayIntersectionMaskPrimitive_t" # not next, but next-next uint32 is the size "VROverlayIntersectionMaskPrimitive_t" # not next, but next-next uint32 is the size
] ]
@ -839,6 +843,9 @@ def handle_method_c(klass, method, winclassname, out):
for i, p in enumerate(method.get_arguments())] for i, p in enumerate(method.get_arguments())]
params = [declspec(p, names[i], "w_") for i, p in enumerate(method.get_arguments())] params = [declspec(p, names[i], "w_") 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)}
if returns_record: if returns_record:
params = [f'{declspec(method.result_type, "*_ret", "w_")}'] + params params = [f'{declspec(method.result_type, "*_ret", "w_")}'] + params
names = ['_ret'] + names names = ['_ret'] + names
@ -853,11 +860,35 @@ def handle_method_c(klass, method, winclassname, out):
out(f'{ret}__thiscall {winclassname}_{method.name}({", ".join(params)})\n') out(f'{ret}__thiscall {winclassname}_{method.name}({", ".join(params)})\n')
out(u'{\n') out(u'{\n')
names = names[2:] if returns_record else names[1:]
params = list(zip(names, method.get_arguments()))
params += [(None, None)]
param_sizes = {}
for i, (name, param) in enumerate(params[:-1]):
if name not in need_convert:
continue
real_type = underlying_type(param)
if strip_ns(real_type.spelling) not in STRUCTS_NEXT_IS_SIZE:
continue
assert name not in STRUCTS_IS_INPUT_ARRAY
assert name not in STRUCTS_NEXT_IS_SIZE_UNHANDLED
next_name, next_param = params[i + 1]
if next_param and next_param.type.spelling == "uint32_t":
out(f' {declspec(param.type.get_pointee(), f"w_{name}", "w_")};\n')
param_sizes[name] = next_name
out(f' struct {method.full_name}_params params =\n') out(f' struct {method.full_name}_params params =\n')
out(u' {\n') out(u' {\n')
out(u' .linux_side = _this->u_iface,\n') out(u' .linux_side = _this->u_iface,\n')
for name in names[1:]: if returns_record:
out(f' .{name} = {name},\n') out(u' ._ret = _ret,\n')
for name, param in params[:-1]:
if name in param_sizes:
out(f' .{name} = {name} ? &w_{name} : NULL,\n')
else:
out(f' .{name} = {name},\n')
out(u' };\n') out(u' };\n')
out(u' TRACE("%p\\n", _this);\n') out(u' TRACE("%p\\n", _this);\n')
@ -865,7 +896,12 @@ def handle_method_c(klass, method, winclassname, out):
if 'eTextureType' in names: if 'eTextureType' in names:
out(u' if (eTextureType == TextureType_DirectX) FIXME( "Not implemented Direct3D API!\\n" );\n') out(u' if (eTextureType == TextureType_DirectX) FIXME( "Not implemented Direct3D API!\\n" );\n')
for name, size in param_sizes.items():
out(f' {size} = min( {size}, sizeof(w_{name}) );\n')
out(f' if ({name}) memcpy( &w_{name}, {name}, {size} );\n')
out(f' VRCLIENT_CALL( {method.full_name}, &params );\n') out(f' VRCLIENT_CALL( {method.full_name}, &params );\n')
for name, size in param_sizes.items():
out(f' if ({name}) memcpy( {name}, &w_{name}, {size} );\n')
if not returns_void: if not returns_void:
out(u' return params._ret;\n') out(u' return params._ret;\n')

30
vrclient_x64/vrinput_manual.c
View File

@ -69,18 +69,22 @@ uint32_t __thiscall winIVRInput_IVRInput_004_GetDigitalActionData( struct w_stea
w_InputDigitalActionData_t *pActionData, w_InputDigitalActionData_t *pActionData,
uint32_t unActionDataSize, uint32_t ulRestrictToDevice ) uint32_t unActionDataSize, uint32_t ulRestrictToDevice )
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_004_GetDigitalActionData_params params = struct IVRInput_IVRInput_004_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE( "%p\n", _this ); TRACE( "%p\n", _this );
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_004_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_004_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
#ifdef __x86_64__ #ifdef __x86_64__
return params._ret; return params._ret;
#else #else
@ -93,18 +97,22 @@ uint32_t __thiscall winIVRInput_IVRInput_005_GetDigitalActionData( struct w_stea
w_InputDigitalActionData_t *pActionData, w_InputDigitalActionData_t *pActionData,
uint32_t unActionDataSize, uint32_t ulRestrictToDevice ) uint32_t unActionDataSize, uint32_t ulRestrictToDevice )
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_005_GetDigitalActionData_params params = struct IVRInput_IVRInput_005_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE( "%p\n", _this ); TRACE( "%p\n", _this );
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_005_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_005_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
#ifdef __x86_64__ #ifdef __x86_64__
return params._ret; return params._ret;
#else #else
@ -117,18 +125,22 @@ uint32_t __thiscall winIVRInput_IVRInput_006_GetDigitalActionData( struct w_stea
w_InputDigitalActionData_t *pActionData, w_InputDigitalActionData_t *pActionData,
uint32_t unActionDataSize, uint32_t ulRestrictToDevice ) uint32_t unActionDataSize, uint32_t ulRestrictToDevice )
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_006_GetDigitalActionData_params params = struct IVRInput_IVRInput_006_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE( "%p\n", _this ); TRACE( "%p\n", _this );
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
#ifdef __x86_64__ #ifdef __x86_64__
return params._ret; return params._ret;
#else #else
@ -141,18 +153,22 @@ uint32_t __thiscall winIVRInput_IVRInput_007_GetDigitalActionData( struct w_stea
w_InputDigitalActionData_t *pActionData, w_InputDigitalActionData_t *pActionData,
uint32_t unActionDataSize, uint32_t ulRestrictToDevice ) uint32_t unActionDataSize, uint32_t ulRestrictToDevice )
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_007_GetDigitalActionData_params params = struct IVRInput_IVRInput_007_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE( "%p\n", _this ); TRACE( "%p\n", _this );
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
#ifdef __x86_64__ #ifdef __x86_64__
return params._ret; return params._ret;
#else #else
@ -165,18 +181,22 @@ uint32_t __thiscall winIVRInput_IVRInput_010_GetDigitalActionData( struct w_stea
w_InputDigitalActionData_t *pActionData, w_InputDigitalActionData_t *pActionData,
uint32_t unActionDataSize, uint32_t ulRestrictToDevice ) uint32_t unActionDataSize, uint32_t ulRestrictToDevice )
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_010_GetDigitalActionData_params params = struct IVRInput_IVRInput_010_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE( "%p\n", _this ); TRACE( "%p\n", _this );
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
#ifdef __x86_64__ #ifdef __x86_64__
return params._ret; return params._ret;
#else #else

162
vrclient_x64/winIVRInput.c
View File

@ -93,45 +93,57 @@ uint32_t __thiscall winIVRInput_IVRInput_003_UpdateActionState(struct w_steam_if
uint32_t __thiscall winIVRInput_IVRInput_003_GetDigitalActionData(struct w_steam_iface *_this, uint64_t action, w_InputDigitalActionData_t *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_003_GetDigitalActionData(struct w_steam_iface *_this, uint64_t action, w_InputDigitalActionData_t *pActionData, uint32_t unActionDataSize)
{ {
w_InputDigitalActionData_t w_pActionData;
struct IVRInput_IVRInput_003_GetDigitalActionData_params params = struct IVRInput_IVRInput_003_GetDigitalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_003_GetDigitalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_003_GetDigitalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_003_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_003_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_003_GetAnalogActionData_params params = struct IVRInput_IVRInput_003_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_003_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_003_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_003_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_003_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_003_GetPoseActionData_params params = struct IVRInput_IVRInput_003_GetPoseActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_003_GetPoseActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_003_GetPoseActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -233,15 +245,19 @@ uint32_t __thiscall winIVRInput_IVRInput_003_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_003_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_003_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_003_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_003_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }
@ -442,48 +458,60 @@ extern uint32_t __thiscall winIVRInput_IVRInput_004_GetDigitalActionData(struct
uint32_t __thiscall winIVRInput_IVRInput_004_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_004_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_004_GetAnalogActionData_params params = struct IVRInput_IVRInput_004_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_004_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_004_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_004_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_004_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_004_GetPoseActionData_params params = struct IVRInput_IVRInput_004_GetPoseActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_004_GetPoseActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_004_GetPoseActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_004_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_1016 *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_004_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_1016 *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputSkeletalActionData_t_1016 w_pActionData;
struct IVRInput_IVRInput_004_GetSkeletalActionData_params params = struct IVRInput_IVRInput_004_GetSkeletalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_004_GetSkeletalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_004_GetSkeletalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -586,15 +614,19 @@ uint32_t __thiscall winIVRInput_IVRInput_004_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_004_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_004_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_004_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_004_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }
@ -804,47 +836,59 @@ extern uint32_t __thiscall winIVRInput_IVRInput_005_GetDigitalActionData(struct
uint32_t __thiscall winIVRInput_IVRInput_005_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_005_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_005_GetAnalogActionData_params params = struct IVRInput_IVRInput_005_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_005_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_005_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_005_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_005_GetPoseActionData(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_005_GetPoseActionData_params params = struct IVRInput_IVRInput_005_GetPoseActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_005_GetPoseActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_005_GetPoseActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_005_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_005_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize)
{ {
w_InputSkeletalActionData_t_113b w_pActionData;
struct IVRInput_IVRInput_005_GetSkeletalActionData_params params = struct IVRInput_IVRInput_005_GetSkeletalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_005_GetSkeletalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_005_GetSkeletalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -1029,15 +1073,19 @@ uint32_t __thiscall winIVRInput_IVRInput_005_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_005_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_005_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_005_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_005_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_005_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_005_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }
@ -1273,63 +1321,79 @@ extern uint32_t __thiscall winIVRInput_IVRInput_006_GetDigitalActionData(struct
uint32_t __thiscall winIVRInput_IVRInput_006_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_006_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_006_GetAnalogActionData_params params = struct IVRInput_IVRInput_006_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_006_GetPoseActionDataRelativeToNow_params params = struct IVRInput_IVRInput_006_GetPoseActionDataRelativeToNow_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetPoseActionDataRelativeToNow, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetPoseActionDataRelativeToNow, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_006_GetPoseActionDataForNextFrame_params params = struct IVRInput_IVRInput_006_GetPoseActionDataForNextFrame_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetPoseActionDataForNextFrame, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetPoseActionDataForNextFrame, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_006_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_006_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize)
{ {
w_InputSkeletalActionData_t_113b w_pActionData;
struct IVRInput_IVRInput_006_GetSkeletalActionData_params params = struct IVRInput_IVRInput_006_GetSkeletalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetSkeletalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetSkeletalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -1515,15 +1579,19 @@ uint32_t __thiscall winIVRInput_IVRInput_006_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_006_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_006_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_006_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_006_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }
@ -1763,63 +1831,79 @@ extern uint32_t __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(struct
uint32_t __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_007_GetAnalogActionData_params params = struct IVRInput_IVRInput_007_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_007_GetPoseActionDataRelativeToNow_params params = struct IVRInput_IVRInput_007_GetPoseActionDataRelativeToNow_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_007_GetPoseActionDataForNextFrame_params params = struct IVRInput_IVRInput_007_GetPoseActionDataForNextFrame_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetPoseActionDataForNextFrame, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetPoseActionDataForNextFrame, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize)
{ {
w_InputSkeletalActionData_t_113b w_pActionData;
struct IVRInput_IVRInput_007_GetSkeletalActionData_params params = struct IVRInput_IVRInput_007_GetSkeletalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetSkeletalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetSkeletalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -2005,15 +2089,19 @@ uint32_t __thiscall winIVRInput_IVRInput_007_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_007_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_007_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_007_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_007_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }
@ -2292,63 +2380,79 @@ extern uint32_t __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(struct
uint32_t __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(struct w_steam_iface *_this, uint64_t action, w_InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputAnalogActionData_t w_pActionData;
struct IVRInput_IVRInput_010_GetAnalogActionData_params params = struct IVRInput_IVRInput_010_GetAnalogActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetAnalogActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetAnalogActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, float fPredictedSecondsFromNow, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_010_GetPoseActionDataRelativeToNow_params params = struct IVRInput_IVRInput_010_GetPoseActionDataRelativeToNow_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.fPredictedSecondsFromNow = fPredictedSecondsFromNow, .fPredictedSecondsFromNow = fPredictedSecondsFromNow,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetPoseActionDataRelativeToNow, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetPoseActionDataRelativeToNow, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice) uint32_t __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(struct w_steam_iface *_this, uint64_t action, uint32_t eOrigin, w_InputPoseActionData_t *pActionData, uint32_t unActionDataSize, uint64_t ulRestrictToDevice)
{ {
w_InputPoseActionData_t w_pActionData;
struct IVRInput_IVRInput_010_GetPoseActionDataForNextFrame_params params = struct IVRInput_IVRInput_010_GetPoseActionDataForNextFrame_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
.ulRestrictToDevice = ulRestrictToDevice, .ulRestrictToDevice = ulRestrictToDevice,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetPoseActionDataForNextFrame, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetPoseActionDataForNextFrame, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize) uint32_t __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(struct w_steam_iface *_this, uint64_t action, w_InputSkeletalActionData_t_113b *pActionData, uint32_t unActionDataSize)
{ {
w_InputSkeletalActionData_t_113b w_pActionData;
struct IVRInput_IVRInput_010_GetSkeletalActionData_params params = struct IVRInput_IVRInput_010_GetSkeletalActionData_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.action = action, .action = action,
.pActionData = pActionData, .pActionData = pActionData ? &w_pActionData : NULL,
.unActionDataSize = unActionDataSize, .unActionDataSize = unActionDataSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unActionDataSize = min( unActionDataSize, sizeof(w_pActionData) );
if (pActionData) memcpy( &w_pActionData, pActionData, unActionDataSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetSkeletalActionData, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetSkeletalActionData, &params );
if (pActionData) memcpy( pActionData, &w_pActionData, unActionDataSize );
return params._ret; return params._ret;
} }
@ -2558,15 +2662,19 @@ uint32_t __thiscall winIVRInput_IVRInput_010_GetOriginLocalizedName(struct w_ste
uint32_t __thiscall winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize) uint32_t __thiscall winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(struct w_steam_iface *_this, uint64_t origin, w_InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize)
{ {
w_InputOriginInfo_t w_pOriginInfo;
struct IVRInput_IVRInput_010_GetOriginTrackedDeviceInfo_params params = struct IVRInput_IVRInput_010_GetOriginTrackedDeviceInfo_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.origin = origin, .origin = origin,
.pOriginInfo = pOriginInfo, .pOriginInfo = pOriginInfo ? &w_pOriginInfo : NULL,
.unOriginInfoSize = unOriginInfoSize, .unOriginInfoSize = unOriginInfoSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unOriginInfoSize = min( unOriginInfoSize, sizeof(w_pOriginInfo) );
if (pOriginInfo) memcpy( &w_pOriginInfo, pOriginInfo, unOriginInfoSize );
VRCLIENT_CALL( IVRInput_IVRInput_010_GetOriginTrackedDeviceInfo, &params ); VRCLIENT_CALL( IVRInput_IVRInput_010_GetOriginTrackedDeviceInfo, &params );
if (pOriginInfo) memcpy( pOriginInfo, &w_pOriginInfo, unOriginInfoSize );
return params._ret; return params._ret;
} }

96
vrclient_x64/winIVROverlay.c
View File

@ -6385,15 +6385,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_010_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_010_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_010_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_0918 w_pEvent;
struct IVROverlay_IVROverlay_010_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_010_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_010_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_010_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -7478,15 +7482,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_011_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_011_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_011_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_0918 w_pEvent;
struct IVROverlay_IVROverlay_011_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_011_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_011_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_011_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -8612,15 +8620,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_012_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_012_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_101 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_012_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_101 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_101 w_pEvent;
struct IVROverlay_IVROverlay_012_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_012_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_012_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_012_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -9819,15 +9831,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_013_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_013_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_013_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_103 w_pEvent;
struct IVROverlay_IVROverlay_013_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_013_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_013_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_013_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -11053,15 +11069,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_014_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_014_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_014_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_106 w_pEvent;
struct IVROverlay_IVROverlay_014_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_014_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_014_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_014_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -12399,15 +12419,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_016_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_016_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_016_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_106 w_pEvent;
struct IVROverlay_IVROverlay_016_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_016_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_016_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_016_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -13769,15 +13793,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_017_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_017_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_017_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1011 w_pEvent;
struct IVROverlay_IVROverlay_017_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_017_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_017_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_017_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -15172,15 +15200,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1016 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1016 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1016 w_pEvent;
struct IVROverlay_IVROverlay_018_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_018_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_018_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_018_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -16560,15 +16592,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_019_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVROverlay_IVROverlay_019_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_019_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_019_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_019_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -17923,15 +17959,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_020_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_020_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_020_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVROverlay_IVROverlay_020_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_020_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_020_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_020_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -19276,15 +19316,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_021_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_021_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVROverlay_IVROverlay_021_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_021_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_021_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_021_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -20616,15 +20660,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_022_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_022_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_022_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVROverlay_IVROverlay_022_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_022_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_022_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_022_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -21974,15 +22022,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_024_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_024_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_11030 w_pEvent;
struct IVROverlay_IVROverlay_024_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_024_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_024_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_024_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -23311,15 +23363,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinat
int8_t __thiscall winIVROverlay_IVROverlay_025_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_025_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1168 w_pEvent;
struct IVROverlay_IVROverlay_025_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_025_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_025_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_025_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -24691,15 +24747,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_026_WaitFrameSync(struct w_steam_if
int8_t __thiscall winIVROverlay_IVROverlay_026_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_026_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1168 w_pEvent;
struct IVROverlay_IVROverlay_026_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_026_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_026_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_026_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -26047,15 +26107,19 @@ uint32_t __thiscall winIVROverlay_IVROverlay_027_WaitFrameSync(struct w_steam_if
int8_t __thiscall winIVROverlay_IVROverlay_027_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVROverlay_IVROverlay_027_PollNextOverlayEvent(struct w_steam_iface *_this, uint64_t ulOverlayHandle, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1168 w_pEvent;
struct IVROverlay_IVROverlay_027_PollNextOverlayEvent_params params = struct IVROverlay_IVROverlay_027_PollNextOverlayEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.ulOverlayHandle = ulOverlayHandle, .ulOverlayHandle = ulOverlayHandle,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVROverlay_IVROverlay_027_PollNextOverlayEvent, &params ); VRCLIENT_CALL( IVROverlay_IVROverlay_027_PollNextOverlayEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }

216
vrclient_x64/winIVRSystem.c
View File

@ -4475,29 +4475,37 @@ const char * __thiscall winIVRSystem_IVRSystem_011_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_011_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_011_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_0918 w_pEvent;
struct IVRSystem_IVRSystem_011_PollNextEvent_params params = struct IVRSystem_IVRSystem_011_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_011_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_011_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_011_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_011_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_0918 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_0918 w_pEvent;
struct IVRSystem_IVRSystem_011_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_011_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_011_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_011_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -5233,29 +5241,37 @@ const char * __thiscall winIVRSystem_IVRSystem_012_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_012_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_012_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_103 w_pEvent;
struct IVRSystem_IVRSystem_012_PollNextEvent_params params = struct IVRSystem_IVRSystem_012_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_012_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_012_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_012_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_012_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_103 w_pEvent;
struct IVRSystem_IVRSystem_012_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_012_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_012_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_012_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -5965,29 +5981,37 @@ const char * __thiscall winIVRSystem_IVRSystem_014_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_014_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_014_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_103 w_pEvent;
struct IVRSystem_IVRSystem_014_PollNextEvent_params params = struct IVRSystem_IVRSystem_014_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_014_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_014_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_014_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_014_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_103 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_103 w_pEvent;
struct IVRSystem_IVRSystem_014_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_014_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_014_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_014_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -6019,31 +6043,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_014_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_014_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_014_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_014_GetControllerState_params params = struct IVRSystem_IVRSystem_014_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_014_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_014_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_014_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_014_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_014_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_014_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_014_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_014_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -6699,29 +6731,37 @@ const char * __thiscall winIVRSystem_IVRSystem_015_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_015_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_015_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_106 w_pEvent;
struct IVRSystem_IVRSystem_015_PollNextEvent_params params = struct IVRSystem_IVRSystem_015_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_015_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_015_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_015_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_015_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_106 w_pEvent;
struct IVRSystem_IVRSystem_015_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_015_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_015_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_015_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -6753,31 +6793,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_015_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_015_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_015_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_015_GetControllerState_params params = struct IVRSystem_IVRSystem_015_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_015_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_015_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_015_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_015_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_015_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_015_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_015_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_015_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -7446,29 +7494,37 @@ const char * __thiscall winIVRSystem_IVRSystem_016_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_016_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_016_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_106 w_pEvent;
struct IVRSystem_IVRSystem_016_PollNextEvent_params params = struct IVRSystem_IVRSystem_016_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_016_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_016_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_016_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_016_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_106 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_106 w_pEvent;
struct IVRSystem_IVRSystem_016_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_016_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_016_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_016_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -7500,31 +7556,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_016_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_016_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_016_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_016_GetControllerState_params params = struct IVRSystem_IVRSystem_016_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_016_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_016_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_016_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_016_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_016_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_016_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_016_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_016_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -8196,29 +8260,37 @@ const char * __thiscall winIVRSystem_IVRSystem_017_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_017_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_017_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1011 w_pEvent;
struct IVRSystem_IVRSystem_017_PollNextEvent_params params = struct IVRSystem_IVRSystem_017_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_017_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_017_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_017_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_017_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1011 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_1011 w_pEvent;
struct IVRSystem_IVRSystem_017_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_017_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_017_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_017_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -8250,31 +8322,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_017_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_017_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_017_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_017_GetControllerState_params params = struct IVRSystem_IVRSystem_017_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_017_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_017_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_017_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_017_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_017_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_017_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_017_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_017_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -8965,29 +9045,37 @@ const char * __thiscall winIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVRSystem_IVRSystem_019_PollNextEvent_params params = struct IVRSystem_IVRSystem_019_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_019_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_019_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVRSystem_IVRSystem_019_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_019_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_019_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_019_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -9019,31 +9107,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_019_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_019_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_019_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_019_GetControllerState_params params = struct IVRSystem_IVRSystem_019_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_019_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_019_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_019_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_019_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_019_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_019_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -9751,29 +9847,37 @@ const char * __thiscall winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_020_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_020_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVRSystem_IVRSystem_020_PollNextEvent_params params = struct IVRSystem_IVRSystem_020_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_020_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_020_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_020_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_020_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1322 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_1322 w_pEvent;
struct IVRSystem_IVRSystem_020_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_020_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_020_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_020_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -9805,31 +9909,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_020_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_020_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_020_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_020_GetControllerState_params params = struct IVRSystem_IVRSystem_020_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_020_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_020_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_020_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_020_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_020_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_020_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_020_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_020_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -10547,29 +10659,37 @@ const char * __thiscall winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_021_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_021_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_11030 w_pEvent;
struct IVRSystem_IVRSystem_021_PollNextEvent_params params = struct IVRSystem_IVRSystem_021_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_021_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_021_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_021_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_021_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_11030 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_11030 w_pEvent;
struct IVRSystem_IVRSystem_021_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_021_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_021_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_021_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -10601,31 +10721,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_021_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_021_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_021_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_021_GetControllerState_params params = struct IVRSystem_IVRSystem_021_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_021_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_021_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_021_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_021_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_021_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_021_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_021_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_021_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
@ -11320,29 +11448,37 @@ const char * __thiscall winIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(stru
int8_t __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent) int8_t __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(struct w_steam_iface *_this, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent)
{ {
w_VREvent_t_1168 w_pEvent;
struct IVRSystem_IVRSystem_022_PollNextEvent_params params = struct IVRSystem_IVRSystem_022_PollNextEvent_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_022_PollNextEvent, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_022_PollNextEvent, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(struct w_steam_iface *_this, uint32_t eOrigin, w_VREvent_t_1168 *pEvent, uint32_t uncbVREvent, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VREvent_t_1168 w_pEvent;
struct IVRSystem_IVRSystem_022_PollNextEventWithPose_params params = struct IVRSystem_IVRSystem_022_PollNextEventWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.pEvent = pEvent, .pEvent = pEvent ? &w_pEvent : NULL,
.uncbVREvent = uncbVREvent, .uncbVREvent = uncbVREvent,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
uncbVREvent = min( uncbVREvent, sizeof(w_pEvent) );
if (pEvent) memcpy( &w_pEvent, pEvent, uncbVREvent );
VRCLIENT_CALL( IVRSystem_IVRSystem_022_PollNextEventWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_022_PollNextEventWithPose, &params );
if (pEvent) memcpy( pEvent, &w_pEvent, uncbVREvent );
return params._ret; return params._ret;
} }
@ -11374,31 +11510,39 @@ w_HiddenAreaMesh_t * __thiscall winIVRSystem_IVRSystem_022_GetHiddenAreaMesh(str
int8_t __thiscall winIVRSystem_IVRSystem_022_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize) int8_t __thiscall winIVRSystem_IVRSystem_022_GetControllerState(struct w_steam_iface *_this, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_022_GetControllerState_params params = struct IVRSystem_IVRSystem_022_GetControllerState_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_022_GetControllerState, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_022_GetControllerState, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }
int8_t __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose) int8_t __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(struct w_steam_iface *_this, uint32_t eOrigin, uint32_t unControllerDeviceIndex, w_VRControllerState001_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose)
{ {
w_VRControllerState001_t w_pControllerState;
struct IVRSystem_IVRSystem_022_GetControllerStateWithPose_params params = struct IVRSystem_IVRSystem_022_GetControllerStateWithPose_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.eOrigin = eOrigin, .eOrigin = eOrigin,
.unControllerDeviceIndex = unControllerDeviceIndex, .unControllerDeviceIndex = unControllerDeviceIndex,
.pControllerState = pControllerState, .pControllerState = pControllerState ? &w_pControllerState : NULL,
.unControllerStateSize = unControllerStateSize, .unControllerStateSize = unControllerStateSize,
.pTrackedDevicePose = pTrackedDevicePose, .pTrackedDevicePose = pTrackedDevicePose,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
unControllerStateSize = min( unControllerStateSize, sizeof(w_pControllerState) );
if (pControllerState) memcpy( &w_pControllerState, pControllerState, unControllerStateSize );
VRCLIENT_CALL( IVRSystem_IVRSystem_022_GetControllerStateWithPose, &params ); VRCLIENT_CALL( IVRSystem_IVRSystem_022_GetControllerStateWithPose, &params );
if (pControllerState) memcpy( pControllerState, &w_pControllerState, unControllerStateSize );
return params._ret; return params._ret;
} }

54
vrclient_x64/winIVRTrackedCamera.c
View File

@ -892,6 +892,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreami
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer_params params = struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -899,11 +900,14 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrame
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pFrameBuffer = pFrameBuffer, .pFrameBuffer = pFrameBuffer,
.nFrameBufferSize = nFrameBufferSize, .nFrameBufferSize = nFrameBufferSize,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
@ -925,6 +929,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextu
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11_params params = struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -932,27 +937,34 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextu
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pD3D11DeviceOrResource = pD3D11DeviceOrResource, .pD3D11DeviceOrResource = pD3D11DeviceOrResource,
.ppD3D11ShaderResourceView = ppD3D11ShaderResourceView, .ppD3D11ShaderResourceView = ppD3D11ShaderResourceView,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL_params params = struct IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.hTrackedCamera = hTrackedCamera, .hTrackedCamera = hTrackedCamera,
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pglTextureId = pglTextureId, .pglTextureId = pglTextureId,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
@ -1154,6 +1166,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_ReleaseVideoStreami
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer_params params = struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -1161,11 +1174,14 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrame
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pFrameBuffer = pFrameBuffer, .pFrameBuffer = pFrameBuffer,
.nFrameBufferSize = nFrameBufferSize, .nFrameBufferSize = nFrameBufferSize,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
@ -1187,6 +1203,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextu
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11_params params = struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -1194,27 +1211,34 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextu
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pD3D11DeviceOrResource = pD3D11DeviceOrResource, .pD3D11DeviceOrResource = pD3D11DeviceOrResource,
.ppD3D11ShaderResourceView = ppD3D11ShaderResourceView, .ppD3D11ShaderResourceView = ppD3D11ShaderResourceView,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL_params params = struct IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.hTrackedCamera = hTrackedCamera, .hTrackedCamera = hTrackedCamera,
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pglTextureId = pglTextureId, .pglTextureId = pglTextureId,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
@ -1418,6 +1442,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStreami
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer_params params = struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -1425,11 +1450,14 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrame
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pFrameBuffer = pFrameBuffer, .pFrameBuffer = pFrameBuffer,
.nFrameBufferSize = nFrameBufferSize, .nFrameBufferSize = nFrameBufferSize,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
@ -1451,6 +1479,7 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextu
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11_params params = struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
@ -1458,27 +1487,34 @@ uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextu
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pD3D11DeviceOrResource = pD3D11DeviceOrResource, .pD3D11DeviceOrResource = pD3D11DeviceOrResource,
.ppD3D11ShaderResourceView = ppD3D11ShaderResourceView, .ppD3D11ShaderResourceView = ppD3D11ShaderResourceView,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }
uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize) uint32_t __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(struct w_steam_iface *_this, uint64_t hTrackedCamera, uint32_t eFrameType, uint32_t *pglTextureId, w_CameraVideoStreamFrameHeader_t_1017 *pFrameHeader, uint32_t nFrameHeaderSize)
{ {
w_CameraVideoStreamFrameHeader_t_1017 w_pFrameHeader;
struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL_params params = struct IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL_params params =
{ {
.linux_side = _this->u_iface, .linux_side = _this->u_iface,
.hTrackedCamera = hTrackedCamera, .hTrackedCamera = hTrackedCamera,
.eFrameType = eFrameType, .eFrameType = eFrameType,
.pglTextureId = pglTextureId, .pglTextureId = pglTextureId,
.pFrameHeader = pFrameHeader, .pFrameHeader = pFrameHeader ? &w_pFrameHeader : NULL,
.nFrameHeaderSize = nFrameHeaderSize, .nFrameHeaderSize = nFrameHeaderSize,
}; };
TRACE("%p\n", _this); TRACE("%p\n", _this);
nFrameHeaderSize = min( nFrameHeaderSize, sizeof(w_pFrameHeader) );
if (pFrameHeader) memcpy( &w_pFrameHeader, pFrameHeader, nFrameHeaderSize );
VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL, &params ); VRCLIENT_CALL( IVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL, &params );
if (pFrameHeader) memcpy( pFrameHeader, &w_pFrameHeader, nFrameHeaderSize );
return params._ret; return params._ret;
} }