Suyu/Yucom
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/Yucom.git synced 2025-12-21 21:26:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

lsteamclient: Wrap parameters in structures.

Browse source 
CW-Bug-Id: #22729
This commit is contained in:
Rémi Bernon 2023-09-27 14:34:23 +02:00 • committed by Arkadiusz Hiler
parent e4d75b2fb0
commit 6b21c32d2a
439 changed files with 109952 additions and 43685 deletions
Download patch file Download diff file Expand all files Collapse all files

132
lsteamclient/cppISteamNetworking_SteamNetworking006.cpp
View file

@ -12,158 +12,114 @@ extern "C" {
#define SDKVER_158
#include "struct_converters.h"
#include "cppISteamNetworking_SteamNetworking006.h"
bool cppISteamNetworking_SteamNetworking006_SendP2PPacket(void *linux_side, CSteamID steamIDRemote, const void *pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel)
void cppISteamNetworking_SteamNetworking006_SendP2PPacket( struct cppISteamNetworking_SteamNetworking006_SendP2PPacket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->SendP2PPacket((CSteamID)steamIDRemote, (const void *)pubData, (uint32)cubData, (EP2PSend)eP2PSendType, (int)nChannel);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->SendP2PPacket( (CSteamID)params->steamIDRemote, (const void *)params->pubData, (uint32)params->cubData, (EP2PSend)params->eP2PSendType, (int)params->nChannel );
}
bool cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable(void *linux_side, uint32 *pcubMsgSize, int nChannel)
void cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable( struct cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->IsP2PPacketAvailable((uint32 *)pcubMsgSize, (int)nChannel);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->IsP2PPacketAvailable( (uint32 *)params->pcubMsgSize, (int)params->nChannel );
}
bool cppISteamNetworking_SteamNetworking006_ReadP2PPacket(void *linux_side, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, CSteamID *psteamIDRemote, int nChannel)
void cppISteamNetworking_SteamNetworking006_ReadP2PPacket( struct cppISteamNetworking_SteamNetworking006_ReadP2PPacket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->ReadP2PPacket((void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize, (CSteamID *)psteamIDRemote, (int)nChannel);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->ReadP2PPacket( (void *)params->pubDest, (uint32)params->cubDest, (uint32 *)params->pcubMsgSize, (CSteamID *)params->psteamIDRemote, (int)params->nChannel );
}
bool cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser(void *linux_side, CSteamID steamIDRemote)
void cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser( struct cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->AcceptP2PSessionWithUser((CSteamID)steamIDRemote);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->AcceptP2PSessionWithUser( (CSteamID)params->steamIDRemote );
}
bool cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser(void *linux_side, CSteamID steamIDRemote)
void cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser( struct cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->CloseP2PSessionWithUser((CSteamID)steamIDRemote);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->CloseP2PSessionWithUser( (CSteamID)params->steamIDRemote );
}
bool cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser(void *linux_side, CSteamID steamIDRemote, int nChannel)
void cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser( struct cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->CloseP2PChannelWithUser((CSteamID)steamIDRemote, (int)nChannel);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->CloseP2PChannelWithUser( (CSteamID)params->steamIDRemote, (int)params->nChannel );
}
bool cppISteamNetworking_SteamNetworking006_GetP2PSessionState(void *linux_side, CSteamID steamIDRemote, P2PSessionState_t *pConnectionState)
void cppISteamNetworking_SteamNetworking006_GetP2PSessionState( struct cppISteamNetworking_SteamNetworking006_GetP2PSessionState_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->GetP2PSessionState((CSteamID)steamIDRemote, (P2PSessionState_t *)pConnectionState);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->GetP2PSessionState( (CSteamID)params->steamIDRemote, (P2PSessionState_t *)params->pConnectionState );
}
bool cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay(void *linux_side, bool bAllow)
void cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay( struct cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->AllowP2PPacketRelay((bool)bAllow);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->AllowP2PPacketRelay( (bool)params->bAllow );
}
SNetListenSocket_t cppISteamNetworking_SteamNetworking006_CreateListenSocket(void *linux_side, int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay)
void cppISteamNetworking_SteamNetworking006_CreateListenSocket( struct cppISteamNetworking_SteamNetworking006_CreateListenSocket_params *params )
{
SNetListenSocket_t _ret;
_ret = ((ISteamNetworking*)linux_side)->CreateListenSocket((int)nVirtualP2PPort, (SteamIPAddress_t)nIP, (uint16)nPort, (bool)bAllowUseOfPacketRelay);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->CreateListenSocket( (int)params->nVirtualP2PPort, (SteamIPAddress_t)params->nIP, (uint16)params->nPort, (bool)params->bAllowUseOfPacketRelay );
}
SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket(void *linux_side, CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay)
void cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket( struct cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket_params *params )
{
SNetSocket_t _ret;
_ret = ((ISteamNetworking*)linux_side)->CreateP2PConnectionSocket((CSteamID)steamIDTarget, (int)nVirtualPort, (int)nTimeoutSec, (bool)bAllowUseOfPacketRelay);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->CreateP2PConnectionSocket( (CSteamID)params->steamIDTarget, (int)params->nVirtualPort, (int)params->nTimeoutSec, (bool)params->bAllowUseOfPacketRelay );
}
SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateConnectionSocket(void *linux_side, SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec)
void cppISteamNetworking_SteamNetworking006_CreateConnectionSocket( struct cppISteamNetworking_SteamNetworking006_CreateConnectionSocket_params *params )
{
SNetSocket_t _ret;
_ret = ((ISteamNetworking*)linux_side)->CreateConnectionSocket((SteamIPAddress_t)nIP, (uint16)nPort, (int)nTimeoutSec);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->CreateConnectionSocket( (SteamIPAddress_t)params->nIP, (uint16)params->nPort, (int)params->nTimeoutSec );
}
bool cppISteamNetworking_SteamNetworking006_DestroySocket(void *linux_side, SNetSocket_t hSocket, bool bNotifyRemoteEnd)
void cppISteamNetworking_SteamNetworking006_DestroySocket( struct cppISteamNetworking_SteamNetworking006_DestroySocket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->DestroySocket((SNetSocket_t)hSocket, (bool)bNotifyRemoteEnd);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->DestroySocket( (SNetSocket_t)params->hSocket, (bool)params->bNotifyRemoteEnd );
}
bool cppISteamNetworking_SteamNetworking006_DestroyListenSocket(void *linux_side, SNetListenSocket_t hSocket, bool bNotifyRemoteEnd)
void cppISteamNetworking_SteamNetworking006_DestroyListenSocket( struct cppISteamNetworking_SteamNetworking006_DestroyListenSocket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->DestroyListenSocket((SNetListenSocket_t)hSocket, (bool)bNotifyRemoteEnd);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->DestroyListenSocket( (SNetListenSocket_t)params->hSocket, (bool)params->bNotifyRemoteEnd );
}
bool cppISteamNetworking_SteamNetworking006_SendDataOnSocket(void *linux_side, SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable)
void cppISteamNetworking_SteamNetworking006_SendDataOnSocket( struct cppISteamNetworking_SteamNetworking006_SendDataOnSocket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->SendDataOnSocket((SNetSocket_t)hSocket, (void *)pubData, (uint32)cubData, (bool)bReliable);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->SendDataOnSocket( (SNetSocket_t)params->hSocket, (void *)params->pubData, (uint32)params->cubData, (bool)params->bReliable );
}
bool cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket(void *linux_side, SNetSocket_t hSocket, uint32 *pcubMsgSize)
void cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket( struct cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->IsDataAvailableOnSocket((SNetSocket_t)hSocket, (uint32 *)pcubMsgSize);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->IsDataAvailableOnSocket( (SNetSocket_t)params->hSocket, (uint32 *)params->pcubMsgSize );
}
bool cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket(void *linux_side, SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize)
void cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket( struct cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->RetrieveDataFromSocket((SNetSocket_t)hSocket, (void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->RetrieveDataFromSocket( (SNetSocket_t)params->hSocket, (void *)params->pubDest, (uint32)params->cubDest, (uint32 *)params->pcubMsgSize );
}
bool cppISteamNetworking_SteamNetworking006_IsDataAvailable(void *linux_side, SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket)
void cppISteamNetworking_SteamNetworking006_IsDataAvailable( struct cppISteamNetworking_SteamNetworking006_IsDataAvailable_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->IsDataAvailable((SNetListenSocket_t)hListenSocket, (uint32 *)pcubMsgSize, (SNetSocket_t *)phSocket);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->IsDataAvailable( (SNetListenSocket_t)params->hListenSocket, (uint32 *)params->pcubMsgSize, (SNetSocket_t *)params->phSocket );
}
bool cppISteamNetworking_SteamNetworking006_RetrieveData(void *linux_side, SNetListenSocket_t hListenSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, SNetSocket_t *phSocket)
void cppISteamNetworking_SteamNetworking006_RetrieveData( struct cppISteamNetworking_SteamNetworking006_RetrieveData_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->RetrieveData((SNetListenSocket_t)hListenSocket, (void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize, (SNetSocket_t *)phSocket);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->RetrieveData( (SNetListenSocket_t)params->hListenSocket, (void *)params->pubDest, (uint32)params->cubDest, (uint32 *)params->pcubMsgSize, (SNetSocket_t *)params->phSocket );
}
bool cppISteamNetworking_SteamNetworking006_GetSocketInfo(void *linux_side, SNetSocket_t hSocket, CSteamID *pSteamIDRemote, int *peSocketStatus, SteamIPAddress_t *punIPRemote, uint16 *punPortRemote)
void cppISteamNetworking_SteamNetworking006_GetSocketInfo( struct cppISteamNetworking_SteamNetworking006_GetSocketInfo_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->GetSocketInfo((SNetSocket_t)hSocket, (CSteamID *)pSteamIDRemote, (int *)peSocketStatus, (SteamIPAddress_t *)punIPRemote, (uint16 *)punPortRemote);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->GetSocketInfo( (SNetSocket_t)params->hSocket, (CSteamID *)params->pSteamIDRemote, (int *)params->peSocketStatus, (SteamIPAddress_t *)params->punIPRemote, (uint16 *)params->punPortRemote );
}
bool cppISteamNetworking_SteamNetworking006_GetListenSocketInfo(void *linux_side, SNetListenSocket_t hListenSocket, SteamIPAddress_t *pnIP, uint16 *pnPort)
void cppISteamNetworking_SteamNetworking006_GetListenSocketInfo( struct cppISteamNetworking_SteamNetworking006_GetListenSocketInfo_params *params )
{
bool _ret;
_ret = ((ISteamNetworking*)linux_side)->GetListenSocketInfo((SNetListenSocket_t)hListenSocket, (SteamIPAddress_t *)pnIP, (uint16 *)pnPort);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->GetListenSocketInfo( (SNetListenSocket_t)params->hListenSocket, (SteamIPAddress_t *)params->pnIP, (uint16 *)params->pnPort );
}
ESNetSocketConnectionType cppISteamNetworking_SteamNetworking006_GetSocketConnectionType(void *linux_side, SNetSocket_t hSocket)
void cppISteamNetworking_SteamNetworking006_GetSocketConnectionType( struct cppISteamNetworking_SteamNetworking006_GetSocketConnectionType_params *params )
{
ESNetSocketConnectionType _ret;
_ret = ((ISteamNetworking*)linux_side)->GetSocketConnectionType((SNetSocket_t)hSocket);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->GetSocketConnectionType( (SNetSocket_t)params->hSocket );
}
int cppISteamNetworking_SteamNetworking006_GetMaxPacketSize(void *linux_side, SNetSocket_t hSocket)
void cppISteamNetworking_SteamNetworking006_GetMaxPacketSize( struct cppISteamNetworking_SteamNetworking006_GetMaxPacketSize_params *params )
{
int _ret;
_ret = ((ISteamNetworking*)linux_side)->GetMaxPacketSize((SNetSocket_t)hSocket);
return (_ret);
params->_ret = ((ISteamNetworking*)params->linux_side)->GetMaxPacketSize( (SNetSocket_t)params->hSocket );
}
#ifdef __cplusplus