mirror/goldberg_emulator
1
0
Fork 0
mirror of https://gitlab.com/Mr_Goldberg/goldberg_emulator.git synced 2025-12-05 11:44:53 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'master' into overlay_h

Browse source
This commit is contained in:
Nemirtingas 2019-08-01 15:56:43 +02:00
commit 884f147e1b
39 changed files with 2255 additions and 22082 deletions
Download patch file Download diff file Expand all files Collapse all files

2
dll/dll.cpp
View file

@ -161,6 +161,8 @@ S_API void * S_CALLTYPE SteamInternal_CreateInterface( const char *ver )
steam_client = (ISteamClient016 *)get_steam_client();
} else if (strcmp(ver, "SteamClient017") == 0) {
steam_client = (ISteamClient017 *)get_steam_client();
} else if (strcmp(ver, "SteamClient018") == 0) {
steam_client = (ISteamClient018 *)get_steam_client();
} else if (strcmp(ver, STEAMCLIENT_INTERFACE_VERSION) == 0) {
steam_client = (ISteamClient *)get_steam_client();
} else {

376
dll/flat.cpp
View file

@ -197,6 +197,11 @@ S_API class ISteamParties * SteamAPI_ISteamClient_GetISteamParties(intptr_t inst
return get_steam_client()->GetISteamParties(hSteamUser, hSteamPipe, pchVersion);
}
S_API class ISteamRemotePlay * SteamAPI_ISteamClient_GetISteamRemotePlay(intptr_t instancePtr, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
{
return get_steam_client()->GetISteamRemotePlay(hSteamUser, hSteamPipe, pchVersion);
}
S_API HSteamUser SteamAPI_ISteamUser_GetHSteamUser(intptr_t instancePtr)
{
return (get_steam_client()->steam_user)->GetHSteamUser();
@ -347,6 +352,11 @@ S_API SteamAPICall_t SteamAPI_ISteamUser_GetMarketEligibility(intptr_t instanceP
return (get_steam_client()->steam_user)->GetMarketEligibility();
}
S_API SteamAPICall_t SteamAPI_ISteamUser_GetDurationControl(intptr_t instancePtr)
{
return (get_steam_client()->steam_user)->GetDurationControl();
}
S_API const char * SteamAPI_ISteamFriends_GetPersonaName(intptr_t instancePtr)
{
return (get_steam_client()->steam_friends)->GetPersonaName();
@ -714,147 +724,386 @@ S_API int SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages(intptr_t
S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceAppActive(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetSecondsSinceAppActive();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetSecondsSinceAppActive();
}
S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceComputerActive(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetSecondsSinceComputerActive();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetSecondsSinceComputerActive();
}
S_API EUniverse SteamAPI_ISteamUtils_GetConnectedUniverse(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetConnectedUniverse();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetConnectedUniverse();
}
S_API uint32 SteamAPI_ISteamUtils_GetServerRealTime(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetServerRealTime();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetServerRealTime();
}
S_API const char * SteamAPI_ISteamUtils_GetIPCountry(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetIPCountry();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetIPCountry();
}
S_API bool SteamAPI_ISteamUtils_GetImageSize(intptr_t instancePtr, int iImage, uint32 * pnWidth, uint32 * pnHeight)
{
return ((ISteamUtils *)instancePtr)->GetImageSize(iImage, pnWidth, pnHeight);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetImageSize(iImage, pnWidth, pnHeight);
}
S_API bool SteamAPI_ISteamUtils_GetImageRGBA(intptr_t instancePtr, int iImage, uint8 * pubDest, int nDestBufferSize)
{
return ((ISteamUtils *)instancePtr)->GetImageRGBA(iImage, pubDest, nDestBufferSize);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetImageRGBA(iImage, pubDest, nDestBufferSize);
}
S_API bool SteamAPI_ISteamUtils_GetCSERIPPort(intptr_t instancePtr, uint32 * unIP, uint16 * usPort)
{
return ((ISteamUtils *)instancePtr)->GetCSERIPPort(unIP, usPort);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetCSERIPPort(unIP, usPort);
}
S_API uint8 SteamAPI_ISteamUtils_GetCurrentBatteryPower(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetCurrentBatteryPower();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetCurrentBatteryPower();
}
S_API uint32 SteamAPI_ISteamUtils_GetAppID(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetAppID();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetAppID();
}
S_API void SteamAPI_ISteamUtils_SetOverlayNotificationPosition(intptr_t instancePtr, ENotificationPosition eNotificationPosition)
{
return ((ISteamUtils *)instancePtr)->SetOverlayNotificationPosition(eNotificationPosition);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->SetOverlayNotificationPosition(eNotificationPosition);
}
S_API bool SteamAPI_ISteamUtils_IsAPICallCompleted(intptr_t instancePtr, SteamAPICall_t hSteamAPICall, bool * pbFailed)
{
return ((ISteamUtils *)instancePtr)->IsAPICallCompleted(hSteamAPICall, pbFailed);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsAPICallCompleted(hSteamAPICall, pbFailed);
}
S_API ESteamAPICallFailure SteamAPI_ISteamUtils_GetAPICallFailureReason(intptr_t instancePtr, SteamAPICall_t hSteamAPICall)
{
return ((ISteamUtils *)instancePtr)->GetAPICallFailureReason(hSteamAPICall);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetAPICallFailureReason(hSteamAPICall);
}
S_API bool SteamAPI_ISteamUtils_GetAPICallResult(intptr_t instancePtr, SteamAPICall_t hSteamAPICall, void * pCallback, int cubCallback, int iCallbackExpected, bool * pbFailed)
{
return ((ISteamUtils *)instancePtr)->GetAPICallResult(hSteamAPICall, pCallback, cubCallback, iCallbackExpected, pbFailed);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetAPICallResult(hSteamAPICall, pCallback, cubCallback, iCallbackExpected, pbFailed);
}
S_API uint32 SteamAPI_ISteamUtils_GetIPCCallCount(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetIPCCallCount();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetIPCCallCount();
}
S_API void SteamAPI_ISteamUtils_SetWarningMessageHook(intptr_t instancePtr, SteamAPIWarningMessageHook_t pFunction)
{
return ((ISteamUtils *)instancePtr)->SetWarningMessageHook(pFunction);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->SetWarningMessageHook(pFunction);
}
S_API bool SteamAPI_ISteamUtils_IsOverlayEnabled(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->IsOverlayEnabled();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsOverlayEnabled();
}
S_API bool SteamAPI_ISteamUtils_BOverlayNeedsPresent(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->BOverlayNeedsPresent();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->BOverlayNeedsPresent();
}
S_API SteamAPICall_t SteamAPI_ISteamUtils_CheckFileSignature(intptr_t instancePtr, const char * szFileName)
{
return ((ISteamUtils *)instancePtr)->CheckFileSignature(szFileName);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->CheckFileSignature(szFileName);
}
S_API bool SteamAPI_ISteamUtils_ShowGamepadTextInput(intptr_t instancePtr, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32 unCharMax, const char * pchExistingText)
{
return ((ISteamUtils *)instancePtr)->ShowGamepadTextInput(eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->ShowGamepadTextInput(eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText);
}
S_API uint32 SteamAPI_ISteamUtils_GetEnteredGamepadTextLength(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetEnteredGamepadTextLength();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetEnteredGamepadTextLength();
}
S_API bool SteamAPI_ISteamUtils_GetEnteredGamepadTextInput(intptr_t instancePtr, char * pchText, uint32 cchText)
{
return ((ISteamUtils *)instancePtr)->GetEnteredGamepadTextInput(pchText, cchText);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetEnteredGamepadTextInput(pchText, cchText);
}
S_API const char * SteamAPI_ISteamUtils_GetSteamUILanguage(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->GetSteamUILanguage();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->GetSteamUILanguage();
}
S_API bool SteamAPI_ISteamUtils_IsSteamRunningInVR(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->IsSteamRunningInVR();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsSteamRunningInVR();
}
S_API void SteamAPI_ISteamUtils_SetOverlayNotificationInset(intptr_t instancePtr, int nHorizontalInset, int nVerticalInset)
{
return ((ISteamUtils *)instancePtr)->SetOverlayNotificationInset(nHorizontalInset, nVerticalInset);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->SetOverlayNotificationInset(nHorizontalInset, nVerticalInset);
}
S_API bool SteamAPI_ISteamUtils_IsSteamInBigPictureMode(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->IsSteamInBigPictureMode();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsSteamInBigPictureMode();
}
S_API void SteamAPI_ISteamUtils_StartVRDashboard(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->StartVRDashboard();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->StartVRDashboard();
}
S_API bool SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled(intptr_t instancePtr)
{
return ((ISteamUtils *)instancePtr)->IsVRHeadsetStreamingEnabled();
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsVRHeadsetStreamingEnabled();
}
S_API void SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled(intptr_t instancePtr, bool bEnabled)
{
return ((ISteamUtils *)instancePtr)->SetVRHeadsetStreamingEnabled(bEnabled);
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->SetVRHeadsetStreamingEnabled(bEnabled);
}
S_API bool SteamAPI_ISteamUtils_IsSteamChinaLauncher(intptr_t instancePtr)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->IsSteamChinaLauncher();
}
S_API bool SteamAPI_ISteamUtils_InitFilterText(intptr_t instancePtr)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->InitFilterText();
}
S_API int SteamAPI_ISteamUtils_FilterText(intptr_t instancePtr, char * pchOutFilteredText, uint32 nByteSizeOutFilteredText, const char * pchInputMessage, bool bLegalOnly)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_utils);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_utils);
auto ptr = get_steam_client()->steam_gameserver_utils;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_utils;
}
return (ptr)->FilterText(pchOutFilteredText, nByteSizeOutFilteredText, pchInputMessage, bLegalOnly);
}
S_API int SteamAPI_ISteamMatchmaking_GetFavoriteGameCount(intptr_t instancePtr)
@ -2597,6 +2846,16 @@ S_API EInputActionOrigin SteamAPI_ISteamInput_TranslateActionOrigin(intptr_t ins
return (get_steam_client()->steam_controller)->TranslateActionOrigin(eDestinationInputType, eSourceOrigin);
}
S_API bool SteamAPI_ISteamInput_GetDeviceBindingRevision(intptr_t instancePtr, InputHandle_t inputHandle, int * pMajor, int * pMinor)
{
return (get_steam_client()->steam_controller)->GetDeviceBindingRevision(inputHandle, pMajor, pMinor);
}
S_API uint32 SteamAPI_ISteamInput_GetRemotePlaySessionID(intptr_t instancePtr, InputHandle_t inputHandle)
{
return (get_steam_client()->steam_controller)->GetRemotePlaySessionID(inputHandle);
}
S_API bool SteamAPI_ISteamController_Init(intptr_t instancePtr)
{
return (get_steam_client()->steam_controller)->Init();
@ -2762,6 +3021,11 @@ S_API EControllerActionOrigin SteamAPI_ISteamController_TranslateActionOrigin(in
return (get_steam_client()->steam_controller)->TranslateActionOrigin(eDestinationInputType, eSourceOrigin);
}
S_API bool SteamAPI_ISteamController_GetControllerBindingRevision(intptr_t instancePtr, ControllerHandle_t controllerHandle, int * pMajor, int * pMinor)
{
return (get_steam_client()->steam_controller)->GetControllerBindingRevision(controllerHandle, pMajor, pMinor);
}
S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest(intptr_t instancePtr, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_ugc);
@ -2930,6 +3194,18 @@ S_API bool SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag(intptr_t instancePtr, UGCQu
return (ptr)->GetQueryUGCKeyValueTag(handle, index, keyValueTagIndex, pchKey, cchKeySize, pchValue, cchValueSize);
}
S_API bool SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag0(intptr_t instancePtr, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_ugc);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_ugc);
auto ptr = get_steam_client()->steam_gameserver_ugc;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_ugc;
}
return (ptr)->GetQueryUGCKeyValueTag(handle, index, pchKey, pchValue, cchValueSize);
}
S_API bool SteamAPI_ISteamUGC_ReleaseQueryUGCRequest(intptr_t instancePtr, UGCQueryHandle_t handle)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_ugc);
@ -3290,6 +3566,18 @@ S_API bool SteamAPI_ISteamUGC_SetAllowLegacyUpload(intptr_t instancePtr, UGCUpda
return (ptr)->SetAllowLegacyUpload(handle, bAllowLegacyUpload);
}
S_API bool SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags(intptr_t instancePtr, UGCUpdateHandle_t handle)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_ugc);
int test2 = ((char *)instancePtr - (char*)get_steam_client()->steam_gameserver_ugc);
auto ptr = get_steam_client()->steam_gameserver_ugc;
if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
ptr = get_steam_client()->steam_ugc;
}
return (ptr)->RemoveAllItemKeyValueTags(handle);
}
S_API bool SteamAPI_ISteamUGC_RemoveItemKeyValueTags(intptr_t instancePtr, UGCUpdateHandle_t handle, const char * pchKey)
{
int test1 = ((char *)instancePtr - (char*)get_steam_client()->steam_ugc);
@ -4378,6 +4666,36 @@ S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList(intptr_t instan
return ((ISteamParentalSettings *)instancePtr)->BIsFeatureInBlockList(eFeature);
}
S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionCount(intptr_t instancePtr)
{
return ((ISteamRemotePlay *)instancePtr)->GetSessionCount();
}
S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionID(intptr_t instancePtr, int iSessionIndex)
{
return ((ISteamRemotePlay *)instancePtr)->GetSessionID(iSessionIndex);
}
S_API uint64 SteamAPI_ISteamRemotePlay_GetSessionSteamID(intptr_t instancePtr, uint32 unSessionID)
{
return ((ISteamRemotePlay *)instancePtr)->GetSessionSteamID(unSessionID).ConvertToUint64();
}
S_API const char * SteamAPI_ISteamRemotePlay_GetSessionClientName(intptr_t instancePtr, uint32 unSessionID)
{
return ((ISteamRemotePlay *)instancePtr)->GetSessionClientName(unSessionID);
}
S_API ESteamDeviceFormFactor SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor(intptr_t instancePtr, uint32 unSessionID)
{
return ((ISteamRemotePlay *)instancePtr)->GetSessionClientFormFactor(unSessionID);
}
S_API bool SteamAPI_ISteamRemotePlay_BGetSessionClientResolution(intptr_t instancePtr, uint32 unSessionID, int * pnResolutionX, int * pnResolutionY)
{
return ((ISteamRemotePlay *)instancePtr)->BGetSessionClientResolution(unSessionID, pnResolutionX, pnResolutionY);
}
S_API bool SteamAPI_ISteamGameServer_InitGameServer(intptr_t instancePtr, uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char * pchVersionString)
{
return ((ISteamGameServer *)instancePtr)->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);

17
dll/local_storage.cpp
View file

@ -18,6 +18,8 @@
#include "local_storage.h"
#include <fstream>
#include <algorithm>
#include <iterator>
struct File_Data {
std::string name;
@ -75,12 +77,12 @@ int Local_Storage::store_data_settings(std::string file, char *data, unsigned in
return -1;
}
int Local_Storage::get_file_data(std::string full_path, char *data, unsigned int max_length)
int Local_Storage::get_file_data(std::string full_path, char *data, unsigned int max_length, unsigned int offset)
{
return -1;
}
int Local_Storage::get_data(std::string folder, std::string file, char *data, unsigned int max_length)
int Local_Storage::get_data(std::string folder, std::string file, char *data, unsigned int max_length, unsigned int offset)
{
return -1;
}
@ -535,22 +537,19 @@ int Local_Storage::store_data_settings(std::string file, char *data, unsigned in
return store_file_data(get_global_settings_path(), file, data, length);
}
int Local_Storage::get_file_data(std::string full_path, char *data, unsigned int max_length)
int Local_Storage::get_file_data(std::string full_path, char *data, unsigned int max_length, unsigned int offset)
{
std::ifstream myfile;
myfile.open(full_path, std::ios::binary | std::ios::in);
if (!myfile.is_open()) return -1;
std::streampos size = myfile.tellg();
myfile.seekg (0, std::ios::beg);
if (size > max_length) max_length = size;
myfile.seekg (offset, std::ios::beg);
myfile.read (data, max_length);
myfile.close();
return myfile.gcount();
}
int Local_Storage::get_data(std::string folder, std::string file, char *data, unsigned int max_length)
int Local_Storage::get_data(std::string folder, std::string file, char *data, unsigned int max_length, unsigned int offset)
{
file = sanitize_file_name(file);
if (folder.back() != *PATH_SEPARATOR) {
@ -558,7 +557,7 @@ int Local_Storage::get_data(std::string folder, std::string file, char *data, un
}
std::string full_path = save_directory + appid + folder + file;
return get_file_data(full_path, data, max_length);
return get_file_data(full_path, data, max_length, offset);
}
int Local_Storage::get_data_settings(std::string file, char *data, unsigned int max_length)

5
dll/local_storage.h
View file

@ -16,6 +16,7 @@
<http://www.gnu.org/licenses/>. */
#include "base.h"
#include <vector>
#ifndef LOCAL_STORAGE_INCLUDE
#define LOCAL_STORAGE_INCLUDE
@ -39,14 +40,14 @@ public:
static std::string get_game_settings_path();
static std::string get_user_appdata_path();
Local_Storage(std::string save_directory);
static int get_file_data(std::string full_path, char *data, unsigned int max_length);
static int get_file_data(std::string full_path, char *data, unsigned int max_length, unsigned int offset=0);
void setAppId(uint32 appid);
static int store_file_data(std::string folder, std::string file, char *data, unsigned int length);
static std::vector<std::string> get_filenames_path(std::string path);
int store_data(std::string folder, std::string file, char *data, unsigned int length);
int store_data_settings(std::string file, char *data, unsigned int length);
int get_data(std::string folder, std::string file, char *data, unsigned int max_length);
int get_data(std::string folder, std::string file, char *data, unsigned int max_length, unsigned int offset=0);
int get_data_settings(std::string file, char *data, unsigned int max_length);
int count_files(std::string folder);
bool iterate_file(std::string folder, int index, char *output_filename, int32 *output_size);

24
dll/steam_client.cpp
View file

@ -314,7 +314,7 @@ Steam_Client::Steam_Client()
steam_user_stats = new Steam_User_Stats(settings_client, local_storage, callback_results_client, callbacks_client);
steam_apps = new Steam_Apps(settings_client, callback_results_client);
steam_networking = new Steam_Networking(settings_client, network, callbacks_client, run_every_runcb);
steam_remote_storage = new Steam_Remote_Storage(local_storage, callback_results_client);
steam_remote_storage = new Steam_Remote_Storage(settings_client, local_storage, callback_results_client);
steam_screenshots = new Steam_Screenshots();
steam_http = new Steam_HTTP(settings_client, network, callback_results_client, callbacks_client);
steam_controller = new Steam_Controller();
@ -333,6 +333,7 @@ Steam_Client::Steam_Client()
steam_unified_messages = new Steam_Unified_Messages(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_game_search = new Steam_Game_Search(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_parties = new Steam_Parties(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
steam_remoteplay = new Steam_RemotePlay(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
PRINT_DEBUG("client init gameserver\n");
steam_gameserver = new Steam_GameServer(settings_server, network, callbacks_server);
@ -680,6 +681,8 @@ void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe
if (strcmp(pchVersion, "SteamNetworkingSockets001") == 0) {
return (void *)(ISteamNetworkingSockets001 *) steam_networking_sockets_temp;
} else if (strcmp(pchVersion, "SteamNetworkingSockets002") == 0) {
return (void *)(ISteamNetworkingSockets002 *) steam_networking_sockets_temp;
} else {
return (void *)(ISteamNetworkingSockets *) steam_networking_sockets_temp;
}
@ -694,6 +697,8 @@ void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe
return (void *)(ISteamGameCoordinator *)steam_game_coordinator_temp;
} else if (strstr(pchVersion, "SteamNetworkingUtils") == pchVersion) {
if (strcmp(pchVersion, "SteamNetworkingUtils001") == 0) {
return (void *)(ISteamNetworkingUtils001 *)steam_networking_utils;
} else if (strcmp(pchVersion, STEAMNETWORKINGUTILS_INTERFACE_VERSION) == 0) {
return (void *)(ISteamNetworkingUtils *)steam_networking_utils;
} else {
return (void *)(ISteamNetworkingUtils *)steam_networking_utils;
@ -750,6 +755,8 @@ void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe
return GetISteamParties(hSteamUser, hSteamPipe, pchVersion);
} else if (strstr(pchVersion, "SteamInput") == pchVersion) {
return GetISteamInput(hSteamUser, hSteamPipe, pchVersion);
} else if (strstr(pchVersion, "STEAMREMOTEPLAY_INTERFACE_VERSION") == pchVersion) {
return GetISteamRemotePlay(hSteamUser, hSteamPipe, pchVersion);
} else if (strstr(pchVersion, "STEAMPARENTALSETTINGS_INTERFACE_VERSION") == pchVersion) {
return GetISteamParentalSettings(hSteamUser, hSteamPipe, pchVersion);
} else {
@ -1029,8 +1036,10 @@ ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamP
} else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION010") == 0) {
return (ISteamUGC *)(void *)(ISteamUGC010 *)steam_ugc_temp;
} else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION011") == 0) {
//TODO
return (ISteamUGC *)(void *)(ISteamUGC *)steam_ugc_temp;
//TODO ?
return (ISteamUGC *)(void *)(ISteamUGC012 *)steam_ugc_temp;
} else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION012") == 0) {
return (ISteamUGC *)(void *)(ISteamUGC012 *)steam_ugc_temp;
} else if (strcmp(pchVersion, STEAMUGC_INTERFACE_VERSION) == 0) {
return (ISteamUGC *)(void *)(ISteamUGC *)steam_ugc_temp;
} else {
@ -1209,6 +1218,15 @@ ISteamParties *Steam_Client::GetISteamParties( HSteamUser hSteamUser, HSteamPipe
return steam_parties;
}
ISteamRemotePlay *Steam_Client::GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
{
PRINT_DEBUG("GetISteamRemotePlay %s\n", pchVersion);
if (!hSteamPipe || !hSteamUser) return NULL;
if (!user_logged_in) return NULL;
return steam_remoteplay;
}
void Steam_Client::RegisterCallback( class CCallbackBase *pCallback, int iCallback)
{
int base_callback = (iCallback / 100) * 100;

6
dll/steam_client.h
View file

@ -43,6 +43,7 @@
#include "steam_unified_messages.h"
#include "steam_gamesearch.h"
#include "steam_parties.h"
#include "steam_remoteplay.h"
#include "steam_gameserver.h"
#include "steam_gameserverstats.h"
@ -64,6 +65,7 @@ public ISteamClient014,
public ISteamClient015,
public ISteamClient016,
public ISteamClient017,
public ISteamClient018,
public ISteamClient
{
public:
@ -101,6 +103,7 @@ public:
Steam_Unified_Messages *steam_unified_messages;
Steam_Game_Search *steam_game_search;
Steam_Parties *steam_parties;
Steam_RemotePlay *steam_remoteplay;
Steam_GameServer *steam_gameserver;
Steam_Utils *steam_gameserver_utils;
@ -261,6 +264,9 @@ public:
// Steam Parties interface
ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion );
// Steam Remote Play interface
ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion );
void RegisterCallback( class CCallbackBase *pCallback, int iCallback);
void UnregisterCallback( class CCallbackBase *pCallback);

17
dll/steam_controller.h
View file

@ -350,5 +350,22 @@ EInputActionOrigin TranslateActionOrigin( ESteamInputType eDestinationInputType,
return k_EInputActionOrigin_None;
}
bool GetControllerBindingRevision( ControllerHandle_t controllerHandle, int *pMajor, int *pMinor )
{
PRINT_DEBUG("GetControllerBindingRevision\n");
return false;
}
bool GetDeviceBindingRevision( InputHandle_t inputHandle, int *pMajor, int *pMinor )
{
PRINT_DEBUG("GetDeviceBindingRevision\n");
return false;
}
uint32 GetRemotePlaySessionID( InputHandle_t inputHandle )
{
PRINT_DEBUG("GetRemotePlaySessionID\n");
return 0;
}
};

114
dll/steam_networking_sockets.h
View file

@ -48,6 +48,7 @@ struct Connect_Socket {
class Steam_Networking_Sockets :
public ISteamNetworkingSockets001,
public ISteamNetworkingSockets002,
public ISteamNetworkingSockets
{
class Settings *settings;
@ -866,6 +867,45 @@ bool GetIdentity( SteamNetworkingIdentity *pIdentity )
PRINT_DEBUG("Steam_Networking_Sockets::GetIdentity\n");
}
/// Indicate our desire to be ready participate in authenticated communications.
/// If we are currently not ready, then steps will be taken to obtain the necessary
/// certificates. (This includes a certificate for us, as well as any CA certificates
/// needed to authenticate peers.)
///
/// You can call this at program init time if you know that you are going to
/// be making authenticated connections, so that we will be ready immediately when
/// those connections are attempted. (Note that essentially all connections require
/// authentication, with the exception of ordinary UDP connections with authentication
/// disabled using k_ESteamNetworkingConfig_IP_AllowWithoutAuth.) If you don't call
/// this function, we will wait until a feature is utilized that that necessitates
/// these resources.
///
/// You can also call this function to force a retry, if failure has occurred.
/// Once we make an attempt and fail, we will not automatically retry.
/// In this respect, the behavior of the system after trying and failing is the same
/// as before the first attempt: attempting authenticated communication or calling
/// this function will call the system to attempt to acquire the necessary resources.
///
/// You can use GetAuthenticationStatus or listen for SteamNetAuthenticationStatus_t
/// to monitor the status.
///
/// Returns the current value that would be returned from GetAuthenticationStatus.
ESteamNetworkingAvailability InitAuthentication()
{
PRINT_DEBUG("Steam_Networking_Sockets::InitAuthentication\n");
}
/// Query our readiness to participate in authenticated communications. A
/// SteamNetAuthenticationStatus_t callback is posted any time this status changes,
/// but you can use this function to query it at any time.
///
/// The value of SteamNetAuthenticationStatus_t::m_eAvail is returned. If you only
/// want this high level status, you can pass NULL for pDetails. If you want further
/// details, pass non-NULL to receive them.
ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStatus_t *pDetails )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetAuthenticationStatus\n");
}
//#ifndef STEAMNETWORKINGSOCKETS_OPENSOURCE
@ -971,14 +1011,44 @@ SteamNetworkingPOPID GetHostedDedicatedServerPOPID()
/// This function will fail if SteamDatagramServer_Init has not been called.
///
/// Returns false if the SDR_LISTEN_PORT environment variable is not set.
bool GetHostedDedicatedServerAddress( SteamDatagramHostedAddress *pRouting )
bool GetHostedDedicatedServerAddress001( SteamDatagramHostedAddress *pRouting )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetHostedDedicatedServerAddress %p\n", pRouting);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
pRouting->SetDevAddress(network->getOwnIP(), 27054);
return true;
PRINT_DEBUG("Steam_Networking_Sockets::GetHostedDedicatedServerAddress002 %p\n", pRouting);
return GetHostedDedicatedServerAddress(pRouting) == k_EResultOK;
}
/// Return info about the hosted server. This contains the PoPID of the server,
/// and opaque routing information that can be used by the relays to send traffic
/// to your server.
///
/// You will need to send this information to your backend, and put it in tickets,
/// so that the relays will know how to forward traffic from
/// clients to your server. See SteamDatagramRelayAuthTicket for more info.
///
/// Also, note that the routing information is contained in SteamDatagramGameCoordinatorServerLogin,
/// so if possible, it's preferred to use GetGameCoordinatorServerLogin to send this info
/// to your game coordinator service, and also login securely at the same time.
///
/// On a successful exit, k_EResultOK is returned
///
/// Unsuccessful exit:
/// - Something other than k_EResultOK is returned.
/// - k_EResultInvalidState: We are not configured to listen for SDR (SDR_LISTEN_SOCKET
/// is not set.)
/// - k_EResultPending: we do not (yet) have the authentication information needed.
/// (See GetAuthenticationStatus.) If you use environment variables to pre-fetch
/// the network config, this data should always be available immediately.
/// - A non-localized diagnostic debug message will be placed in m_data that describes
/// the cause of the failure.
///
/// NOTE: The returned blob is not encrypted. Send it to your backend, but don't
/// directly share it with clients.
virtual EResult GetHostedDedicatedServerAddress( SteamDatagramHostedAddress *pRouting )
{
std::lock_guard<std::recursive_mutex> lock(global_mutex);
pRouting->SetDevAddress(network->getOwnIP(), 27054);
return k_EResultOK;
}
/// Create a listen socket on the specified virtual port. The physical UDP port to use
/// will be determined by the SDR_LISTEN_PORT environment variable. If a UDP port is not
@ -1066,6 +1136,40 @@ bool SetConnectionConfigurationValue( HSteamNetConnection hConn, ESteamNetworkin
PRINT_DEBUG("Steam_Networking_Sockets::SetConnectionConfigurationValue\n");
}
/// Generate an authentication blob that can be used to securely login with
/// your backend, using SteamDatagram_ParseHostedServerLogin. (See
/// steamdatagram_gamecoordinator.h)
///
/// Before calling the function:
/// - Populate the app data in pLoginInfo (m_cbAppData and m_appData). You can leave
/// all other fields uninitialized.
/// - *pcbSignedBlob contains the size of the buffer at pBlob. (It should be
/// at least k_cbMaxSteamDatagramGameCoordinatorServerLoginSerialized.)
///
/// On a successful exit:
/// - k_EResultOK is returned
/// - All of the remaining fields of pLoginInfo will be filled out.
/// - *pcbSignedBlob contains the size of the serialized blob that has been
/// placed into pBlob.
///
/// Unsuccessful exit:
/// - Something other than k_EResultOK is returned.
/// - k_EResultNotLoggedOn: you are not logged in (yet)
/// - See GetHostedDedicatedServerAddress for more potential failure return values.
/// - A non-localized diagnostic debug message will be placed in pBlob that describes
/// the cause of the failure.
///
/// This works by signing the contents of the SteamDatagramGameCoordinatorServerLogin
/// with the cert that is issued to this server. In dev environments, it's OK if you do
/// not have a cert. (You will need to enable insecure dev login in SteamDatagram_ParseHostedServerLogin.)
/// Otherwise, you will need a signed cert.
///
/// NOTE: The routing blob returned here is not encrypted. Send it to your backend
/// and don't share it directly with clients.
EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *pLoginInfo, int *pcbSignedBlob, void *pBlob )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetGameCoordinatorServerLogin\n");
}
// TEMP KLUDGE Call to invoke all queued callbacks.
// Eventually this function will go away, and callwacks will be ordinary Steamworks callbacks.

15
dll/steam_networking_utils.h
View file

@ -18,6 +18,7 @@
#include "base.h"
class Steam_Networking_Utils :
public ISteamNetworkingUtils001,
public ISteamNetworkingUtils
{
class Settings *settings;
@ -69,6 +70,20 @@ bool InitializeRelayAccess()
return true;
}
/// Fetch current status of the relay network.
///
/// SteamRelayNetworkStatus_t is also a callback. It will be triggered on
/// both the user and gameserver interfaces any time the status changes, or
/// ping measurement starts or stops.
///
/// SteamRelayNetworkStatus_t::m_eAvail is returned. If you want
/// more details, you can pass a non-NULL value.
ESteamNetworkingAvailability GetRelayNetworkStatus( SteamRelayNetworkStatus_t *pDetails )
{
PRINT_DEBUG("Steam_Networking_Utils::GetRelayNetworkStatus\n");
return k_ESteamNetworkingAvailability_Current;
}
float GetLocalPingLocation( SteamNetworkPingLocation_t &result )
{
PRINT_DEBUG("Steam_Networking_Utils::GetLocalPingLocation\n");

54
dll/steam_remote_storage.h
View file

@ -31,6 +31,10 @@ struct Stream_Write {
std::vector<char> file_data;
};
struct Downloaded_File {
std::string file;
uint64 total_size;
};
class Steam_Remote_Storage :
public ISteamRemoteStorage001,
@ -49,15 +53,19 @@ public ISteamRemoteStorage013,
public ISteamRemoteStorage
{
private:
class Settings *settings;
Local_Storage *local_storage;
class SteamCallResults *callback_results;
bool steam_cloud_enabled;
std::vector<struct Async_Read> async_reads;
std::vector<struct Stream_Write> stream_writes;
std::map<UGCHandle_t, std::string> shared_files;
std::map<UGCHandle_t, struct Downloaded_File> downloaded_files;
public:
Steam_Remote_Storage(Local_Storage *local_storage, class SteamCallResults *callback_results)
Steam_Remote_Storage(class Settings *settings, Local_Storage *local_storage, class SteamCallResults *callback_results)
{
this->settings = settings;
this->local_storage = local_storage;
this->callback_results = callback_results;
steam_cloud_enabled = true;
@ -176,9 +184,14 @@ SteamAPICall_t FileShare( const char *pchFile )
PRINT_DEBUG("Steam_Remote_Storage::FileShare\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
RemoteStorageFileShareResult_t data = {};
data.m_eResult = k_EResultOK;
data.m_hFile = generate_steam_api_call_id();
strncpy(data.m_rgchFilename, pchFile, sizeof(data.m_rgchFilename) - 1);
if (local_storage->file_exists(REMOTE_STORAGE_FOLDER, pchFile)) {
data.m_eResult = k_EResultOK;
data.m_hFile = generate_steam_api_call_id();
strncpy(data.m_rgchFilename, pchFile, sizeof(data.m_rgchFilename) - 1);
shared_files[data.m_hFile] = pchFile;
} else {
data.m_eResult = k_EResultFileNotFound;
}
return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
}
@ -354,12 +367,28 @@ STEAM_CALL_RESULT( RemoteStorageDownloadUGCResult_t )
SteamAPICall_t UGCDownload( UGCHandle_t hContent, uint32 unPriority )
{
PRINT_DEBUG("Steam_Remote_Storage::UGCDownload\n");
RemoteStorageDownloadUGCResult_t data = {};
if (shared_files.count(hContent)) {
data.m_eResult = k_EResultOK;
data.m_hFile = hContent;
data.m_nAppID = settings->get_local_game_id().AppID();
data.m_nSizeInBytes = local_storage->file_size(REMOTE_STORAGE_FOLDER, shared_files[hContent]);
shared_files[hContent].copy(data.m_pchFileName, sizeof(data.m_pchFileName) - 1);
data.m_ulSteamIDOwner = settings->get_local_steam_id().ConvertToUint64();
downloaded_files[hContent].file = shared_files[hContent];
downloaded_files[hContent].total_size = data.m_nSizeInBytes;
} else {
data.m_eResult = k_EResultFileNotFound; //TODO: not sure if this is the right result
}
return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
}
STEAM_CALL_RESULT( RemoteStorageDownloadUGCResult_t )
SteamAPICall_t UGCDownload( UGCHandle_t hContent )
{
PRINT_DEBUG("Steam_Remote_Storage::UGCDownload old\n");
return UGCDownload(hContent, 1);
}
@ -392,16 +421,31 @@ bool GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, STEAM_OUT_STRING() c
int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction )
{
PRINT_DEBUG("Steam_Remote_Storage::UGCRead\n");
if (!downloaded_files.count(hContent) || cubDataToRead < 0) {
return -1; //TODO: is this the right return value?
}
Downloaded_File f = downloaded_files[hContent];
int read_data = local_storage->get_data(REMOTE_STORAGE_FOLDER, f.file, (char* )pvData, cubDataToRead, cOffset);
if (eAction == k_EUGCRead_Close || (eAction == k_EUGCRead_ContinueReadingUntilFinished && (read_data < cubDataToRead || (cOffset + cubDataToRead) >= f.total_size))) {
downloaded_files.erase(hContent);
}
PRINT_DEBUG("Read %i\n", read_data);
return read_data;
}
int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead )
{
PRINT_DEBUG("Steam_Remote_Storage::UGCRead old\n");
return UGCRead( hContent, pvData, cubDataToRead, 0);
}
int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset)
{
PRINT_DEBUG("Steam_Remote_Storage::UGCRead old\n");
PRINT_DEBUG("Steam_Remote_Storage::UGCRead old2\n");
return UGCRead(hContent, pvData, cubDataToRead, cOffset, k_EUGCRead_ContinueReadingUntilFinished);
}
// Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead()

129
dll/steam_remoteplay.h Normal file
View file

@ -0,0 +1,129 @@
/* Copyright (C) 2019 Mr Goldberg
This file is part of the Goldberg Emulator
The Goldberg Emulator is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.
The Goldberg Emulator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the Goldberg Emulator; if not, see
<http://www.gnu.org/licenses/>. */
#include "base.h"
class Steam_RemotePlay :
public ISteamRemotePlay
{
class Settings *settings;
class Networking *network;
class SteamCallResults *callback_results;
class SteamCallBacks *callbacks;
class RunEveryRunCB *run_every_runcb;
public:
static void steam_callback(void *object, Common_Message *msg)
{
PRINT_DEBUG("steam_remoteplay_callback\n");
Steam_RemotePlay *steam_remoteplay = (Steam_RemotePlay *)object;
steam_remoteplay->Callback(msg);
}
static void steam_run_every_runcb(void *object)
{
PRINT_DEBUG("steam_remoteplay_run_every_runcb\n");
Steam_RemotePlay *steam_remoteplay = (Steam_RemotePlay *)object;
steam_remoteplay->RunCallbacks();
}
Steam_RemotePlay(class Settings *settings, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks, class RunEveryRunCB *run_every_runcb)
{
this->settings = settings;
this->network = network;
this->run_every_runcb = run_every_runcb;
//this->network->setCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &Steam_RemotePlay::steam_callback, this);
this->run_every_runcb->add(&Steam_RemotePlay::steam_run_every_runcb, this);
this->callback_results = callback_results;
this->callbacks = callbacks;
}
~Steam_RemotePlay()
{
//TODO rm network callbacks
this->run_every_runcb->remove(&Steam_RemotePlay::steam_run_every_runcb, this);
}
// Get the number of currently connected Steam Remote Play sessions
uint32 GetSessionCount()
{
PRINT_DEBUG("Steam_RemotePlay::GetSessionCount\n");
return 0;
}
// Get the currently connected Steam Remote Play session ID at the specified index. Returns zero if index is out of bounds.
uint32 GetSessionID( int iSessionIndex )
{
PRINT_DEBUG("Steam_RemotePlay::GetSessionID\n");
return 0;
}
// Get the SteamID of the connected user
CSteamID GetSessionSteamID( uint32 unSessionID )
{
PRINT_DEBUG("Steam_RemotePlay::GetSessionSteamID\n");
return k_steamIDNil;
}
// Get the name of the session client device
// This returns NULL if the sessionID is not valid
const char *GetSessionClientName( uint32 unSessionID )
{
PRINT_DEBUG("Steam_RemotePlay::GetSessionClientName\n");
return NULL;
}
// Get the form factor of the session client device
ESteamDeviceFormFactor GetSessionClientFormFactor( uint32 unSessionID )
{
PRINT_DEBUG("Steam_RemotePlay::GetSessionClientFormFactor\n");
return k_ESteamDeviceFormFactorUnknown;
}
// Get the resolution, in pixels, of the session client device
// This is set to 0x0 if the resolution is not available
bool BGetSessionClientResolution( uint32 unSessionID, int *pnResolutionX, int *pnResolutionY )
{
PRINT_DEBUG("Steam_RemotePlay::BGetSessionClientResolution\n");
return false;
}
void RunCallbacks()
{
}
void Callback(Common_Message *msg)
{
if (msg->has_low_level()) {
if (msg->low_level().type() == Low_Level::CONNECT) {
}
if (msg->low_level().type() == Low_Level::DISCONNECT) {
}
}
if (msg->has_networking_sockets()) {
}
}
};

13
dll/steam_ugc.h
View file

@ -36,6 +36,7 @@ public ISteamUGC007,
public ISteamUGC008,
public ISteamUGC009,
public ISteamUGC010,
public ISteamUGC012,
public ISteamUGC
{
class Settings *settings;
@ -245,6 +246,11 @@ bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyVa
return false;
}
bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *pchKey, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize )
{
PRINT_DEBUG("Steam_UGC::GetQueryUGCKeyValueTag2\n");
return false;
}
// Release the request to free up memory, after retrieving results
@ -487,6 +493,13 @@ bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, bool bAllowLegacyUpload )
return false;
}
bool RemoveAllItemKeyValueTags( UGCUpdateHandle_t handle )
{
PRINT_DEBUG("Steam_UGC::RemoveAllItemKeyValueTags\n");
return false;
}
// remove all existing key-value tags (you can add new ones via the AddItemKeyValueTag function)
bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey )
{
PRINT_DEBUG("Steam_UGC::RemoveItemKeyValueTags\n");

9
dll/steam_user.h
View file

@ -448,4 +448,13 @@ SteamAPICall_t GetMarketEligibility()
PRINT_DEBUG("GetMarketEligibility\n");
return 0;
}
// Retrieves anti indulgence / duration control for current user
STEAM_CALL_RESULT( DurationControl_t )
SteamAPICall_t GetDurationControl()
{
PRINT_DEBUG("GetDurationControl\n");
return 0;
}
};

28
dll/steam_utils.h
View file

@ -345,4 +345,32 @@ void SetVRHeadsetStreamingEnabled( bool bEnabled )
{
PRINT_DEBUG("SetVRHeadsetStreamingEnabled\n");
}
// Returns whether this steam client is a Steam China specific client, vs the global client.
bool IsSteamChinaLauncher()
{
PRINT_DEBUG("IsSteamChinaLauncher\n");
return false;
}
// Initializes text filtering.
// Returns false if filtering is unavailable for the language the user is currently running in.
bool InitFilterText()
{
PRINT_DEBUG("InitFilterText\n");
return false;
}
// Filters the provided input message and places the filtered result into pchOutFilteredText.
// pchOutFilteredText is where the output will be placed, even if no filtering or censoring is performed
// nByteSizeOutFilteredText is the size (in bytes) of pchOutFilteredText
// pchInputText is the input string that should be filtered, which can be ASCII or UTF-8
// bLegalOnly should be false if you want profanity and legally required filtering (where required) and true if you want legally required filtering only
// Returns the number of characters (not bytes) filtered.
int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const char * pchInputMessage, bool bLegalOnly )
{
PRINT_DEBUG("FilterText\n");
return 0;
}
};